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=c1546a9bbf11ceaea799923d3adba1ee638bb697;hb=e9e1269514ffbb04e52e0125c195ed9623da18e8;hp=2ca70603d4cf33db7a5ab2131a326cde8d78d0b5;hpb=6b5d20f6513bc3e6e5db4a2058ee81308edaa9c8;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 2ca70603d4..c1546a9bbf 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,20 +7,21 @@ */ package org.opendaylight.yangtools.yang.data.impl.schema.tree; -import com.google.common.base.Optional; import com.google.common.base.Preconditions; import java.util.List; +import java.util.Optional; 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.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; 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.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; @@ -35,35 +36,33 @@ import org.slf4j.LoggerFactory; abstract class SchemaAwareApplyOperation extends ModificationApplyOperation { private static final Logger LOG = LoggerFactory.getLogger(SchemaAwareApplyOperation.class); - public static ModificationApplyOperation from(final DataSchemaNode schemaNode, final TreeType treeType) { - if (treeType == TreeType.CONFIGURATION) { - Preconditions.checkArgument(schemaNode.isConfiguration(), "Supplied %s does not belongs to configuration tree.", schemaNode.getPath()); + 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()); } if (schemaNode instanceof ContainerSchemaNode) { - final ContainerSchemaNode containerSchema = (ContainerSchemaNode) schemaNode; - if (containerSchema.isPresenceContainer()) { - return new PresenceContainerModificationStrategy(containerSchema, treeType); - } else { - return new StructuralContainerModificationStrategy(containerSchema, treeType); - } + return ContainerModificationStrategy.of((ContainerSchemaNode) schemaNode, treeConfig); } else if (schemaNode instanceof ListSchemaNode) { - return fromListSchemaNode((ListSchemaNode) schemaNode, treeType); + return fromListSchemaNode((ListSchemaNode) schemaNode, treeConfig); } else if (schemaNode instanceof ChoiceSchemaNode) { - return new ChoiceModificationStrategy((ChoiceSchemaNode) schemaNode, treeType); + return new ChoiceModificationStrategy((ChoiceSchemaNode) schemaNode, treeConfig); } else if (schemaNode instanceof LeafListSchemaNode) { - return fromLeafListSchemaNode((LeafListSchemaNode) schemaNode, treeType); + return fromLeafListSchemaNode((LeafListSchemaNode) schemaNode, treeConfig); } else if (schemaNode instanceof LeafSchemaNode) { - return new LeafModificationStrategy((LeafSchemaNode) schemaNode, treeType); + return new LeafModificationStrategy((LeafSchemaNode) schemaNode); } throw new IllegalArgumentException("Not supported schema node type for " + schemaNode.getClass()); } public static SchemaAwareApplyOperation from(final DataNodeContainer resolvedTree, - final AugmentationTarget augSchemas, final AugmentationIdentifier identifier, final TreeType treeType) { - for (final AugmentationSchema potential : augSchemas.getAvailableAugmentations()) { + final AugmentationTarget augSchemas, final AugmentationIdentifier identifier, + final DataTreeConfiguration treeConfig) { + for (final AugmentationSchemaNode potential : augSchemas.getAvailableAugmentations()) { for (final DataSchemaNode child : potential.getChildNodes()) { if (identifier.getPossibleChildNames().contains(child.getQName())) { - return new AugmentationModificationStrategy(potential, resolvedTree, treeType); + return new AugmentationModificationStrategy(potential, resolvedTree, treeConfig); } } } @@ -71,37 +70,40 @@ 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, final TreeType treeType) { + private static ModificationApplyOperation fromListSchemaNode(final ListSchemaNode schemaNode, + final DataTreeConfiguration treeConfig) { final List keyDefinition = schemaNode.getKeyDefinition(); final SchemaAwareApplyOperation op; if (keyDefinition == null || keyDefinition.isEmpty()) { - op = new UnkeyedListModificationStrategy(schemaNode, treeType); + op = new UnkeyedListModificationStrategy(schemaNode, treeConfig); } else if (schemaNode.isUserOrdered()) { - op = new OrderedMapModificationStrategy(schemaNode, treeType); + op = new OrderedMapModificationStrategy(schemaNode, treeConfig); } else { - op = new UnorderedMapModificationStrategy(schemaNode, treeType); + op = new UnorderedMapModificationStrategy(schemaNode, treeConfig); } return MinMaxElementsValidation.from(op, schemaNode); } - private static SchemaAwareApplyOperation fromLeafListSchemaNode(final LeafListSchemaNode schemaNode, final TreeType treeType) { + private static ModificationApplyOperation fromLeafListSchemaNode(final LeafListSchemaNode schemaNode, + final DataTreeConfiguration treeConfig) { final SchemaAwareApplyOperation op; - if(schemaNode.isUserOrdered()) { - op = new OrderedLeafSetModificationStrategy(schemaNode, treeType); + if (schemaNode.isUserOrdered()) { + op = new OrderedLeafSetModificationStrategy(schemaNode, treeConfig); } else { - op = new UnorderedLeafSetModificationStrategy(schemaNode, treeType); + op = new UnorderedLeafSetModificationStrategy(schemaNode, treeConfig); } return MinMaxElementsValidation.from(op, schemaNode); } - protected static void checkNotConflicting(final YangInstanceIdentifier path, final TreeNode original, final TreeNode current) throws ConflictingModificationAppliedException { + 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."); checkConflicting(path, original.getSubtreeVersion().equals(current.getSubtreeVersion()), @@ -115,28 +117,30 @@ abstract class SchemaAwareApplyOperation extends ModificationApplyOperation { } @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); - break; - case TOUCH: - checkTouchApplicable(path, modification, current, version); - break; - case WRITE: - checkWriteApplicable(path, modification, current, version); - break; - case MERGE: - checkMergeApplicable(path, modification, current, version); - break; - case NONE: - break; - default: - throw new UnsupportedOperationException("Suplied modification type "+ modification.getOperation()+ " is not supported."); + case DELETE: + checkDeleteApplicable(modification, current); + break; + case TOUCH: + checkTouchApplicable(path, modification, current, version); + break; + case WRITE: + checkWriteApplicable(path, modification, current, version); + break; + case MERGE: + checkMergeApplicable(path, modification, current, version); + break; + case NONE: + break; + default: + throw new UnsupportedOperationException( + "Suplied modification type " + modification.getOperation() + " is not supported."); } } - protected void checkMergeApplicable(final YangInstanceIdentifier path, final NodeModification modification, + 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()) { @@ -146,8 +150,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); } } } @@ -160,17 +166,16 @@ abstract class SchemaAwareApplyOperation extends ModificationApplyOperation { * @param path Path from current node in TreeNode * @param modification modification to apply * @param current current node in TreeNode for modification to apply - * @throws DataValidationFailedException + * @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 { + 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."); } } @@ -187,37 +192,43 @@ abstract class SchemaAwareApplyOperation extends ModificationApplyOperation { } @Override - final Optional apply(final ModifiedNode modification, final Optional currentMeta, final Version version) { + final Optional apply(final ModifiedNode modification, final Optional currentMeta, + final Version version) { switch (modification.getOperation()) { - case DELETE: - // Deletion of a non-existing node is a no-op, report it as such - modification.resolveModificationType(currentMeta.isPresent() ? ModificationType.DELETE : ModificationType.UNMODIFIED); - return modification.setSnapshot(Optional.absent()); - case TOUCH: - Preconditions.checkArgument(currentMeta.isPresent(), "Metadata not available for modification %s", + case DELETE: + // Deletion of a non-existing node is a no-op, report it as such + modification.resolveModificationType(currentMeta.isPresent() ? ModificationType.DELETE + : ModificationType.UNMODIFIED); + return modification.setSnapshot(Optional.empty()); + case TOUCH: + Preconditions.checkArgument(currentMeta.isPresent(), "Metadata not available for modification %s", modification); - return modification.setSnapshot(Optional.of(applyTouch(modification, currentMeta.get(), + return modification.setSnapshot(Optional.of(applyTouch(modification, currentMeta.get(), version))); - case MERGE: - final TreeNode result; + case MERGE: + final TreeNode result; - // This is a slight optimization: a merge on a non-existing node equals to a write - if (currentMeta.isPresent()) { - result = applyMerge(modification, currentMeta.get(), version); - } else { - modification.resolveModificationType(ModificationType.WRITE); - result = applyWrite(modification, currentMeta, version); - } + if (!currentMeta.isPresent()) { + // This is a slight optimization: a merge on a non-existing node equals to a write. Written data + // 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, modification.getWrittenValue(), currentMeta, version); + verifyStructure(result.getData(), true); + } else { + result = applyMerge(modification, currentMeta.get(), version); + } - return modification.setSnapshot(Optional.of(result)); - case WRITE: - modification.resolveModificationType(ModificationType.WRITE); - return modification.setSnapshot(Optional.of(applyWrite(modification, currentMeta, version))); - case NONE: - modification.resolveModificationType(ModificationType.UNMODIFIED); - return currentMeta; - default: - throw new IllegalArgumentException("Provided modification type is not supported."); + return modification.setSnapshot(Optional.of(result)); + case WRITE: + modification.resolveModificationType(ModificationType.WRITE); + return modification.setSnapshot(Optional.of(applyWrite(modification, modification.getWrittenValue(), + currentMeta, version))); + case NONE: + modification.resolveModificationType(ModificationType.UNMODIFIED); + return currentMeta; + default: + throw new IllegalArgumentException("Provided modification type is not supported."); } } @@ -233,7 +244,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 @@ -248,7 +260,6 @@ abstract class SchemaAwareApplyOperation extends ModificationApplyOperation { protected abstract TreeNode applyTouch(ModifiedNode modification, TreeNode currentMeta, Version version); /** - * * Checks is supplied {@link NodeModification} is applicable for Subtree Modification. * * @param path Path to current node @@ -256,9 +267,9 @@ abstract class SchemaAwareApplyOperation extends ModificationApplyOperation { * @param current Current state of data tree * @throws ConflictingModificationAppliedException If subtree was changed in conflicting way * @throws org.opendaylight.yangtools.yang.data.api.schema.tree.IncorrectDataStructureException If subtree - * modification is not applicable (e.g. leaf node). + * modification is not applicable (e.g. leaf node). */ - protected abstract void checkTouchApplicable(YangInstanceIdentifier path, NodeModification modification, + protected abstract void checkTouchApplicable(ModificationPath path, NodeModification modification, Optional current, Version version) throws DataValidationFailedException; /**