BUG-4684: validate changes against effective state
[yangtools.git] / yang / yang-data-impl / src / main / java / org / opendaylight / yangtools / yang / data / impl / schema / tree / SchemaAwareApplyOperation.java
index d7aa826c236f4c375ca9e1bd6c3dccf3f5dd7d42..22a056fca3c0fa4f33854103864cf76135a82891 100644 (file)
@@ -9,27 +9,20 @@ package org.opendaylight.yangtools.yang.data.impl.schema.tree;
 
 import com.google.common.base.Optional;
 import com.google.common.base.Preconditions;
-import com.google.common.collect.Iterables;
+import java.util.List;
 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.NodeIdentifier;
 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.UnkeyedListEntryNode;
 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.spi.MutableTreeNode;
+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.TreeNodeFactory;
 import org.opendaylight.yangtools.yang.data.api.schema.tree.spi.Version;
-import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.NormalizedNodeContainerBuilder;
-import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableUnkeyedListEntryNodeBuilder;
 import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
 import org.opendaylight.yangtools.yang.model.api.AugmentationTarget;
-import org.opendaylight.yangtools.yang.model.api.ChoiceNode;
+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;
@@ -39,43 +32,42 @@ import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import java.util.List;
-
-abstract class SchemaAwareApplyOperation implements ModificationApplyOperation {
+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 DataNodeContainerModificationStrategy.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);
-        } else if (schemaNode instanceof ChoiceNode) {
-            return new NormalizedNodeContainerModificationStrategy.ChoiceModificationStrategy((ChoiceNode) schemaNode);
+            return fromListSchemaNode((ListSchemaNode) schemaNode, treeType);
+        } else if (schemaNode instanceof ChoiceSchemaNode) {
+            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 ValueNodeModificationStrategy.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) {
-        AugmentationSchema augSchema = null;
-
-        allAugments:
-            for (AugmentationSchema potential : augSchemas.getAvailableAugmentations()) {
-                for (DataSchemaNode child : potential.getChildNodes()) {
-                    if (identifier.getPossibleChildNames().contains(child.getQName())) {
-                        augSchema = potential;
-                        break allAugments;
-                    }
+            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, treeType);
                 }
             }
-
-        if (augSchema != null) {
-            return new DataNodeContainerModificationStrategy.AugmentationModificationStrategy(augSchema, resolvedTree);
         }
+
         return null;
     }
 
@@ -86,27 +78,30 @@ abstract class SchemaAwareApplyOperation implements ModificationApplyOperation {
         return condition;
     }
 
-    private static SchemaAwareApplyOperation fromListSchemaNode(final ListSchemaNode schemaNode) {
-        List<QName> keyDefinition = schemaNode.getKeyDefinition();
+    private static SchemaAwareApplyOperation fromListSchemaNode(final ListSchemaNode schemaNode, final TreeType treeType) {
+        final List<QName> keyDefinition = schemaNode.getKeyDefinition();
+        final SchemaAwareApplyOperation op;
         if (keyDefinition == null || keyDefinition.isEmpty()) {
-            return new UnkeyedListModificationStrategy(schemaNode);
-        }
-        if (schemaNode.isUserOrdered()) {
-            return new NormalizedNodeContainerModificationStrategy.OrderedMapModificationStrategy(schemaNode);
+            op = new UnkeyedListModificationStrategy(schemaNode, treeType);
+        } else if (schemaNode.isUserOrdered()) {
+            op =  new OrderedMapModificationStrategy(schemaNode, treeType);
+        } else {
+            op = new UnorderedMapModificationStrategy(schemaNode, treeType);
         }
-
-        return new NormalizedNodeContainerModificationStrategy.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 NormalizedNodeContainerModificationStrategy.OrderedLeafSetModificationStrategy(schemaNode);
+            op =  new OrderedLeafSetModificationStrategy(schemaNode, treeType);
         } else {
-            return new NormalizedNodeContainerModificationStrategy.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()),
@@ -114,42 +109,36 @@ abstract class SchemaAwareApplyOperation implements ModificationApplyOperation {
     }
 
     protected final ModificationApplyOperation resolveChildOperation(final PathArgument child) {
-        Optional<ModificationApplyOperation> potential = getChild(child);
+        final Optional<ModificationApplyOperation> potential = getChild(child);
         Preconditions.checkArgument(potential.isPresent(), "Operation for child %s is not defined.", child);
         return potential.get();
     }
 
     @Override
-    public void verifyStructure(final ModifiedNode modification) throws IllegalArgumentException {
-        if (modification.getType() == ModificationType.WRITE) {
-            verifyWrittenStructure(modification.getWrittenValue());
-        }
-    }
-
-    @Override
-    public final void checkApplicable(final YangInstanceIdentifier path,final NodeModification modification, final Optional<TreeNode> current) throws DataValidationFailedException {
-        switch (modification.getType()) {
+    final void checkApplicable(final YangInstanceIdentifier path,final NodeModification modification, final Optional<TreeNode> current, final Version version) throws DataValidationFailedException {
+        switch (modification.getOperation()) {
         case DELETE:
             checkDeleteApplicable(modification, current);
-        case SUBTREE_MODIFIED:
-            checkSubtreeModificationApplicable(path, modification, current);
-            return;
+            break;
+        case TOUCH:
+            checkTouchApplicable(path, modification, current, version);
+            break;
         case WRITE:
-            checkWriteApplicable(path, modification, current);
-            return;
+            checkWriteApplicable(path, modification, current, version);
+            break;
         case MERGE:
-            checkMergeApplicable(path, modification, current);
-            return;
-        case UNMODIFIED:
-            return;
+            checkMergeApplicable(path, modification, current, version);
+            break;
+        case NONE:
+            break;
         default:
-            throw new UnsupportedOperationException("Suplied modification type "+ modification.getType()+ "is not supported.");
+            throw new UnsupportedOperationException("Suplied modification type "+ modification.getOperation()+ " is not supported.");
         }
-
     }
 
-    protected void checkMergeApplicable(final YangInstanceIdentifier path, final NodeModification modification, final Optional<TreeNode> current) throws DataValidationFailedException {
-        Optional<TreeNode> original = modification.getOriginal();
+    protected void checkMergeApplicable(final YangInstanceIdentifier path, final NodeModification modification,
+            final Optional<TreeNode> current, final Version version) throws DataValidationFailedException {
+        final Optional<TreeNode> original = modification.getOriginal();
         if (original.isPresent() && current.isPresent()) {
             /*
              * We need to do conflict detection only and only if the value of leaf changed
@@ -174,62 +163,89 @@ abstract class SchemaAwareApplyOperation implements ModificationApplyOperation {
      * @throws DataValidationFailedException
      */
     protected void checkWriteApplicable(final YangInstanceIdentifier path, final NodeModification modification,
-        final Optional<TreeNode> current) throws DataValidationFailedException {
-        Optional<TreeNode> original = modification.getOriginal();
+        final Optional<TreeNode> current, final Version version) throws DataValidationFailedException {
+        final Optional<TreeNode> 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<TreeNode> current) {
+    private static void checkDeleteApplicable(final NodeModification modification, final Optional<TreeNode> 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);
         }
     }
 
-    boolean isOrdered() {
-        return false;
+    @Override
+    protected ChildTrackingPolicy getChildPolicy() {
+        return ChildTrackingPolicy.UNORDERED;
     }
 
     @Override
-    public final Optional<TreeNode> apply(final ModifiedNode modification,
-            final Optional<TreeNode> currentMeta, final Version version) {
-
-        switch (modification.getType()) {
+    final Optional<TreeNode> apply(final ModifiedNode modification, final Optional<TreeNode> currentMeta, final Version version) {
+        switch (modification.getOperation()) {
         case DELETE:
-            return modification.storeSnapshot(Optional.<TreeNode> absent());
-        case SUBTREE_MODIFIED:
-            Preconditions.checkArgument(currentMeta.isPresent(), "Metadata not available for modification",
+            // 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.<TreeNode> absent());
+        case TOUCH:
+            Preconditions.checkArgument(currentMeta.isPresent(), "Metadata not available for modification %s",
                     modification);
-            return modification.storeSnapshot(Optional.of(applySubtreeChange(modification, currentMeta.get(),
+            return modification.setSnapshot(Optional.of(applyTouch(modification, currentMeta.get(),
                     version)));
         case MERGE:
-            if(currentMeta.isPresent()) {
-                return modification.storeSnapshot(Optional.of(applyMerge(modification,currentMeta.get(), version)));
+            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);
             }
-            // intentional fall-through: if the node does not exist a merge is same as a write
+
+            return modification.setSnapshot(Optional.of(result));
         case WRITE:
-            return modification.storeSnapshot(Optional.of(applyWrite(modification, currentMeta, version)));
-        case UNMODIFIED:
+            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.");
         }
     }
 
-    protected abstract TreeNode applyMerge(ModifiedNode modification,
-            TreeNode currentMeta, Version version);
+    /**
+     * Apply a merge operation. Since the result of merge differs based on the data type
+     * being modified, implementations of this method are responsible for calling
+     * {@link ModifiedNode#resolveModificationType(ModificationType)} as appropriate.
+     *
+     * @param modification Modified node
+     * @param currentMeta Store Metadata Node on which NodeModification should be applied
+     * @param version New subtree version of parent node
+     * @return A sealed TreeNode representing applied operation.
+     */
+    protected abstract TreeNode applyMerge(ModifiedNode modification, TreeNode currentMeta, Version version);
 
-    protected abstract TreeNode applyWrite(ModifiedNode modification,
-            Optional<TreeNode> currentMeta, Version version);
+    protected abstract TreeNode applyWrite(ModifiedNode modification, Optional<TreeNode> currentMeta, Version version);
 
-    protected abstract TreeNode applySubtreeChange(ModifiedNode modification,
-            TreeNode currentMeta, Version version);
+    /**
+     * Apply a nested operation. Since there may not actually be a nested operation
+     * to be applied, implementations of this method are responsible for calling
+     * {@link ModifiedNode#resolveModificationType(ModificationType)} as appropriate.
+     *
+     * @param modification Modified node
+     * @param currentMeta Store Metadata Node on which NodeModification should be applied
+     * @param version New subtree version of parent node
+     * @return A sealed TreeNode representing applied operation.
+     */
+    protected abstract TreeNode applyTouch(ModifiedNode modification, TreeNode currentMeta, Version version);
 
     /**
      *
@@ -241,117 +257,18 @@ abstract class SchemaAwareApplyOperation implements ModificationApplyOperation {
      * @throws ConflictingModificationAppliedException If subtree was changed in conflicting way
      * @throws IncorrectDataStructureException If subtree modification is not applicable (e.g. leaf node).
      */
-    protected abstract void checkSubtreeModificationApplicable(YangInstanceIdentifier path, final NodeModification modification,
-            final Optional<TreeNode> current) throws DataValidationFailedException;
-
-    protected abstract void verifyWrittenStructure(NormalizedNode<?, ?> writtenValue);
-
-    public static class UnkeyedListModificationStrategy extends SchemaAwareApplyOperation {
-
-        private final Optional<ModificationApplyOperation> entryStrategy;
-
-        protected UnkeyedListModificationStrategy(final ListSchemaNode schema) {
-            entryStrategy = Optional.<ModificationApplyOperation> of(new DataNodeContainerModificationStrategy.UnkeyedListItemModificationStrategy(schema));
-        }
-
-        @Override
-        boolean isOrdered() {
-            return true;
-        }
-
-        @Override
-        protected TreeNode applyMerge(final ModifiedNode modification, final TreeNode currentMeta,
-                final Version version) {
-            return applyWrite(modification, Optional.of(currentMeta), version);
-        }
-
-        @Override
-        protected TreeNode applySubtreeChange(final ModifiedNode modification,
-                final TreeNode currentMeta, final Version version) {
-            throw new UnsupportedOperationException("UnkeyedList does not support subtree change.");
-        }
-
-        @Override
-        protected TreeNode applyWrite(final ModifiedNode modification,
-                final Optional<TreeNode> currentMeta, final Version version) {
-            final NormalizedNode<?, ?> newValue = modification.getWrittenValue();
-            final TreeNode newValueMeta = TreeNodeFactory.createTreeNode(newValue, version);
-
-            if (Iterables.isEmpty(modification.getChildren())) {
-                return newValueMeta;
-            }
-
-            /*
-             * This is where things get interesting. The user has performed a write and
-             * then she applied some more modifications to it. So we need to make sense
-             * of that an apply the operations on top of the written value. We could have
-             * done it during the write, but this operation is potentially expensive, so
-             * we have left it out of the fast path.
-             *
-             * As it turns out, once we materialize the written data, we can share the
-             * code path with the subtree change. So let's create an unsealed TreeNode
-             * and run the common parts on it -- which end with the node being sealed.
-             */
-            final MutableTreeNode mutable = newValueMeta.mutable();
-            mutable.setSubtreeVersion(version);
-
-            @SuppressWarnings("rawtypes")
-            final NormalizedNodeContainerBuilder dataBuilder = ImmutableUnkeyedListEntryNodeBuilder
-                .create((UnkeyedListEntryNode) newValue);
-
-            return mutateChildren(mutable, dataBuilder, version, modification.getChildren());
-        }
-
-        /**
-         * Applies write/remove diff operation for each modification child in modification subtree.
-         * Operation also sets the Data tree references for each Tree Node (Index Node) in meta (MutableTreeNode) structure.
-         *
-         * @param meta MutableTreeNode (IndexTreeNode)
-         * @param data DataBuilder
-         * @param nodeVersion Version of TreeNode
-         * @param modifications modification operations to apply
-         * @return Sealed immutable copy of TreeNode structure with all Data Node references set.
-         */
-        @SuppressWarnings({ "rawtypes", "unchecked" })
-        private TreeNode mutateChildren(final MutableTreeNode meta, final NormalizedNodeContainerBuilder data,
-            final Version nodeVersion, final Iterable<ModifiedNode> modifications) {
-
-            for (ModifiedNode mod : modifications) {
-                final PathArgument id = mod.getIdentifier();
-                final Optional<TreeNode> cm = meta.getChild(id);
+    protected abstract void checkTouchApplicable(YangInstanceIdentifier path, NodeModification modification,
+            Optional<TreeNode> current, Version version) throws DataValidationFailedException;
 
-                Optional<TreeNode> result = resolveChildOperation(id).apply(mod, cm, nodeVersion);
-                if (result.isPresent()) {
-                    final TreeNode tn = result.get();
-                    meta.addChild(tn);
-                    data.addChild(tn.getData());
-                } else {
-                    meta.removeChild(id);
-                    data.removeChild(id);
-                }
-            }
-
-            meta.setData(data.build());
-            return meta.seal();
-        }
-
-        @Override
-        public Optional<ModificationApplyOperation> getChild(final PathArgument child) {
-            if (child instanceof NodeIdentifier) {
-                return entryStrategy;
-            }
-            return Optional.absent();
-        }
-
-        @Override
-        protected void verifyWrittenStructure(final NormalizedNode<?, ?> writtenValue) {
-
-        }
-
-        @Override
-        protected void checkSubtreeModificationApplicable(final YangInstanceIdentifier path, final NodeModification modification,
-                final Optional<TreeNode> current) throws IncorrectDataStructureException {
-            throw new IncorrectDataStructureException(path, "Subtree modification is not allowed.");
-        }
+    /**
+     * 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();
     }
 }