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=a511ddf064b719cb1c0f1320b6da2ec21b98e959;hb=bf405586fc69c3781311cfb8ac19ba93b670ec8d;hp=80ef74cf9a3a8b9bcc44e0fdbec3b514237882db;hpb=b43b9ed6f627a4a1d2ecc6081ed4f0024761e4a3;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 80ef74cf9a..a511ddf064 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 @@ -14,11 +14,10 @@ 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.DataValidationFailedException; -import org.opendaylight.yangtools.yang.data.api.schema.tree.IncorrectDataStructureException; 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; @@ -36,27 +35,35 @@ import org.slf4j.LoggerFactory; abstract class SchemaAwareApplyOperation extends ModificationApplyOperation { private static final Logger LOG = LoggerFactory.getLogger(SchemaAwareApplyOperation.class); - public static SchemaAwareApplyOperation from(final DataSchemaNode schemaNode) { + 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()); + } if (schemaNode instanceof ContainerSchemaNode) { - return new ContainerModificationStrategy((ContainerSchemaNode) schemaNode); + final ContainerSchemaNode containerSchema = (ContainerSchemaNode) schemaNode; + if (containerSchema.isPresenceContainer()) { + return new PresenceContainerModificationStrategy(containerSchema, treeType); + } else { + return new StructuralContainerModificationStrategy(containerSchema, treeType); + } } else if (schemaNode instanceof ListSchemaNode) { - return fromListSchemaNode((ListSchemaNode) schemaNode); + return fromListSchemaNode((ListSchemaNode) schemaNode, treeType); } else if (schemaNode instanceof ChoiceSchemaNode) { - return new ChoiceModificationStrategy((ChoiceSchemaNode) schemaNode); + return new ChoiceModificationStrategy((ChoiceSchemaNode) schemaNode, treeType); } else if (schemaNode instanceof LeafListSchemaNode) { - return fromLeafListSchemaNode((LeafListSchemaNode) schemaNode); + return fromLeafListSchemaNode((LeafListSchemaNode) schemaNode, treeType); } else if (schemaNode instanceof LeafSchemaNode) { - return new LeafModificationStrategy((LeafSchemaNode) schemaNode); + return new LeafModificationStrategy((LeafSchemaNode) schemaNode, treeType); } throw new IllegalArgumentException("Not supported schema node type for " + schemaNode.getClass()); } public static SchemaAwareApplyOperation from(final DataNodeContainer resolvedTree, - final AugmentationTarget augSchemas, final AugmentationIdentifier identifier) { - for (AugmentationSchema potential : augSchemas.getAvailableAugmentations()) { - for (DataSchemaNode child : potential.getChildNodes()) { + final AugmentationTarget augSchemas, final AugmentationIdentifier identifier, final TreeType treeType) { + for (final AugmentationSchema potential : augSchemas.getAvailableAugmentations()) { + for (final DataSchemaNode child : potential.getChildNodes()) { if (identifier.getPossibleChildNames().contains(child.getQName())) { - return new AugmentationModificationStrategy(potential, resolvedTree); + return new AugmentationModificationStrategy(potential, resolvedTree, treeType); } } } @@ -71,27 +78,30 @@ abstract class SchemaAwareApplyOperation extends ModificationApplyOperation { return condition; } - private static SchemaAwareApplyOperation fromListSchemaNode(final ListSchemaNode schemaNode) { - List keyDefinition = schemaNode.getKeyDefinition(); + private static SchemaAwareApplyOperation fromListSchemaNode(final ListSchemaNode schemaNode, final TreeType treeType) { + final List keyDefinition = schemaNode.getKeyDefinition(); + final SchemaAwareApplyOperation op; if (keyDefinition == null || keyDefinition.isEmpty()) { - return new UnkeyedListModificationStrategy(schemaNode); - } - if (schemaNode.isUserOrdered()) { - return new OrderedMapModificationStrategy(schemaNode); + op = new UnkeyedListModificationStrategy(schemaNode, treeType); + } else if (schemaNode.isUserOrdered()) { + op = new OrderedMapModificationStrategy(schemaNode, treeType); + } else { + op = new UnorderedMapModificationStrategy(schemaNode, treeType); } - - return new UnorderedMapModificationStrategy(schemaNode); + return MinMaxElementsValidation.from(op, schemaNode); } - private static SchemaAwareApplyOperation fromLeafListSchemaNode(final LeafListSchemaNode schemaNode) { + private static SchemaAwareApplyOperation fromLeafListSchemaNode(final LeafListSchemaNode schemaNode, final TreeType treeType) { + final SchemaAwareApplyOperation op; if(schemaNode.isUserOrdered()) { - return new OrderedLeafSetModificationStrategy(schemaNode); + op = new OrderedLeafSetModificationStrategy(schemaNode, treeType); } else { - return new UnorderedLeafSetModificationStrategy(schemaNode); + op = new UnorderedLeafSetModificationStrategy(schemaNode, treeType); } + return MinMaxElementsValidation.from(op, schemaNode); } - private static final void checkNotConflicting(final YangInstanceIdentifier path, final TreeNode original, final TreeNode current) throws ConflictingModificationAppliedException { + protected static final void checkNotConflicting(final YangInstanceIdentifier 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()), @@ -99,18 +109,11 @@ abstract class SchemaAwareApplyOperation extends ModificationApplyOperation { } protected final ModificationApplyOperation resolveChildOperation(final PathArgument child) { - Optional potential = getChild(child); + final Optional potential = getChild(child); Preconditions.checkArgument(potential.isPresent(), "Operation for child %s is not defined.", child); return potential.get(); } - @Override - void verifyStructure(final ModifiedNode modification) throws IllegalArgumentException { - if (modification.getOperation() == LogicalOperation.WRITE) { - verifyWrittenStructure(modification.getWrittenValue()); - } - } - @Override final void checkApplicable(final YangInstanceIdentifier path,final NodeModification modification, final Optional current) throws DataValidationFailedException { switch (modification.getOperation()) { @@ -134,7 +137,7 @@ abstract class SchemaAwareApplyOperation extends ModificationApplyOperation { } protected void checkMergeApplicable(final YangInstanceIdentifier path, final NodeModification modification, final Optional current) throws DataValidationFailedException { - Optional original = modification.getOriginal(); + 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 @@ -160,19 +163,19 @@ abstract class SchemaAwareApplyOperation extends ModificationApplyOperation { */ protected void checkWriteApplicable(final YangInstanceIdentifier path, final NodeModification modification, final Optional current) throws DataValidationFailedException { - Optional original = modification.getOriginal(); + 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 if (current.isPresent()) { + throw new ConflictingModificationAppliedException(path, "Node was created by other transaction."); } } - private 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()) { + if (!current.isPresent()) { LOG.trace("Delete operation turned to no-op on missing node {}", modification); } } @@ -186,10 +189,11 @@ abstract class SchemaAwareApplyOperation extends ModificationApplyOperation { final Optional apply(final ModifiedNode modification, final Optional currentMeta, final Version version) { switch (modification.getOperation()) { case DELETE: - modification.resolveModificationType(ModificationType.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", + Preconditions.checkArgument(currentMeta.isPresent(), "Metadata not available for modification %s", modification); return modification.setSnapshot(Optional.of(applyTouch(modification, currentMeta.get(), version))); @@ -198,7 +202,7 @@ abstract class SchemaAwareApplyOperation extends ModificationApplyOperation { // 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); + result = applyMerge(modification, currentMeta.get(), version); } else { modification.resolveModificationType(ModificationType.WRITE); result = applyWrite(modification, currentMeta, version); @@ -255,5 +259,15 @@ abstract class SchemaAwareApplyOperation extends ModificationApplyOperation { protected abstract void checkTouchApplicable(YangInstanceIdentifier path, final NodeModification modification, final Optional current) throws DataValidationFailedException; - protected abstract void verifyWrittenStructure(NormalizedNode writtenValue); + /** + * Checks if supplied schema node belong to specified Data Tree type. All nodes belong to the operational tree, + * nodes in configuration tree are marked as such. + * + * @param treeType Tree Type + * @param node Schema node + * @return + */ + static boolean belongsToTree(final TreeType treeType, final DataSchemaNode node) { + return treeType == TreeType.OPERATIONAL || node.isConfiguration(); + } }