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=22a056fca3c0fa4f33854103864cf76135a82891;hb=e55154f0d2e8208ce1356ddbad281df343f3a508;hp=d7aa826c236f4c375ca9e1bd6c3dccf3f5dd7d42;hpb=4efe0ec503f2aaecc3eac1878f76611ba27c4810;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 d7aa826c23..22a056fca3 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 @@ -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 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 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 potential = getChild(child); + final Optional 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 current) throws DataValidationFailedException { - switch (modification.getType()) { + final void checkApplicable(final YangInstanceIdentifier path,final NodeModification modification, final Optional 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 current) throws DataValidationFailedException { - Optional original = modification.getOriginal(); + protected void checkMergeApplicable(final YangInstanceIdentifier 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 @@ -174,62 +163,89 @@ abstract class SchemaAwareApplyOperation implements ModificationApplyOperation { * @throws DataValidationFailedException */ protected void checkWriteApplicable(final YangInstanceIdentifier path, final NodeModification modification, - final Optional current) throws DataValidationFailedException { - Optional original = modification.getOriginal(); + 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 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); } } - boolean isOrdered() { - return false; + @Override + protected ChildTrackingPolicy getChildPolicy() { + return ChildTrackingPolicy.UNORDERED; } @Override - public final Optional apply(final ModifiedNode modification, - final Optional currentMeta, final Version version) { - - switch (modification.getType()) { + final Optional apply(final ModifiedNode modification, final Optional currentMeta, final Version version) { + switch (modification.getOperation()) { case DELETE: - return modification.storeSnapshot(Optional. 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. 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 currentMeta, Version version); + protected abstract TreeNode applyWrite(ModifiedNode modification, Optional 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 current) throws DataValidationFailedException; - - protected abstract void verifyWrittenStructure(NormalizedNode writtenValue); - - public static class UnkeyedListModificationStrategy extends SchemaAwareApplyOperation { - - private final Optional entryStrategy; - - protected UnkeyedListModificationStrategy(final ListSchemaNode schema) { - entryStrategy = Optional. 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 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 modifications) { - - for (ModifiedNode mod : modifications) { - final PathArgument id = mod.getIdentifier(); - final Optional cm = meta.getChild(id); + protected abstract void checkTouchApplicable(YangInstanceIdentifier path, NodeModification modification, + Optional current, Version version) throws DataValidationFailedException; - Optional 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 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 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(); } }