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%2FAbstractNodeContainerModificationStrategy.java;h=2dc1edeca219e75bf12bb1f55ca5bcb22b9ea57b;hb=9041b2200d7c48962615f414ed884cb54a7573df;hp=b7f2f6003c385d69429c83d69c8e07e28ec60667;hpb=401382e6bb243710d0a93bd7210161ea5994c101;p=yangtools.git diff --git a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/AbstractNodeContainerModificationStrategy.java b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/AbstractNodeContainerModificationStrategy.java index b7f2f6003c..2dc1edeca2 100644 --- a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/AbstractNodeContainerModificationStrategy.java +++ b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/AbstractNodeContainerModificationStrategy.java @@ -8,14 +8,21 @@ package org.opendaylight.yangtools.yang.data.impl.schema.tree; import static com.google.common.base.Preconditions.checkArgument; +import static java.util.Objects.requireNonNull; -import com.google.common.base.Optional; -import com.google.common.base.Preconditions; +import com.google.common.base.MoreObjects; +import com.google.common.base.MoreObjects.ToStringHelper; +import com.google.common.base.Verify; import java.util.Collection; +import java.util.Optional; +import org.eclipse.jdt.annotation.NonNull; +import org.eclipse.jdt.annotation.Nullable; import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier; +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.NormalizedNodeContainer; 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.ModifiedNodeDoesNotExistException; @@ -25,43 +32,140 @@ 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.model.api.DocumentedNode.WithStatus; -abstract class AbstractNodeContainerModificationStrategy extends SchemaAwareApplyOperation { +abstract class AbstractNodeContainerModificationStrategy + extends SchemaAwareApplyOperation { + abstract static class Invisible extends AbstractNodeContainerModificationStrategy { + private final @NonNull SchemaAwareApplyOperation entryStrategy; - private final Class> nodeClass; + Invisible(final NormalizedNodeContainerSupport support, final DataTreeConfiguration treeConfig, + final SchemaAwareApplyOperation entryStrategy) { + super(support, treeConfig); + this.entryStrategy = requireNonNull(entryStrategy); + } + + @Override + final T getSchema() { + return entryStrategy.getSchema(); + } + + final Optional entryStrategy() { + return Optional.of(entryStrategy); + } + + @Override + ToStringHelper addToStringAttributes(final ToStringHelper helper) { + return super.addToStringAttributes(helper).add("entry", entryStrategy); + } + } + + abstract static class Visible extends AbstractNodeContainerModificationStrategy { + private final @NonNull T schema; + + Visible(final NormalizedNodeContainerSupport support, final DataTreeConfiguration treeConfig, + final T schema) { + super(support, treeConfig); + this.schema = requireNonNull(schema); + } + + @Override + final T getSchema() { + return schema; + } + + @Override + ToStringHelper addToStringAttributes(final ToStringHelper helper) { + return super.addToStringAttributes(helper).add("schema", schema); + } + } + + /** + * Fake TreeNode version used in + * {@link #checkTouchApplicable(ModificationPath, NodeModification, Optional, Version)} + * It is okay to use a global constant, as the delegate will ignore it anyway. + */ + private static final Version FAKE_VERSION = Version.initial(); + + private final NormalizedNodeContainerSupport support; private final boolean verifyChildrenStructure; - protected AbstractNodeContainerModificationStrategy(final Class> nodeClass, - final TreeType treeType) { - this.nodeClass = Preconditions.checkNotNull(nodeClass , "nodeClass"); - this.verifyChildrenStructure = (treeType == TreeType.CONFIGURATION); + AbstractNodeContainerModificationStrategy(final NormalizedNodeContainerSupport support, + final DataTreeConfiguration treeConfig) { + this.support = requireNonNull(support); + this.verifyChildrenStructure = treeConfig.getTreeType() == TreeType.CONFIGURATION; } - @SuppressWarnings("rawtypes") @Override - void verifyStructure(final NormalizedNode writtenValue, final boolean verifyChildren) { + protected final ChildTrackingPolicy getChildPolicy() { + return support.childPolicy; + } + + @Override + final void verifyValue(final NormalizedNode writtenValue) { + final Class nodeClass = support.requiredClass; checkArgument(nodeClass.isInstance(writtenValue), "Node %s is not of type %s", writtenValue, nodeClass); checkArgument(writtenValue instanceof NormalizedNodeContainer); - if (verifyChildrenStructure && verifyChildren) { - final NormalizedNodeContainer container = (NormalizedNodeContainer) writtenValue; - for (final Object child : container.getValue()) { - checkArgument(child instanceof NormalizedNode); - final NormalizedNode castedChild = (NormalizedNode) child; - final Optional childOp = getChild(castedChild.getIdentifier()); + } + + @Override + final void verifyValueChildren(final NormalizedNode writtenValue) { + if (verifyChildrenStructure) { + final NormalizedNodeContainer container = (NormalizedNodeContainer) writtenValue; + for (final NormalizedNode child : container.getValue()) { + final Optional childOp = getChild(child.getIdentifier()); if (childOp.isPresent()) { - childOp.get().verifyStructure(castedChild, verifyChildren); + childOp.get().fullVerifyStructure(child); } else { throw new SchemaValidationFailedException(String.format( - "Child %s is not valid child according to schema.", castedChild.getIdentifier())); + "Node %s is not a valid child of %s according to the schema.", + child.getIdentifier(), container.getIdentifier())); } } + + optionalVerifyValueChildren(writtenValue); } + mandatoryVerifyValueChildren(writtenValue); + } + + /** + * Perform additional verification on written value's child structure, like presence of mandatory children and + * exclusion. The default implementation does nothing and is not invoked for non-CONFIG data trees. + * + * @param writtenValue Effective written value + */ + void optionalVerifyValueChildren(final NormalizedNode writtenValue) { + // Defaults to no-op + } + + /** + * Perform additional verification on written value's child structure, like presence of mandatory children. + * The default implementation does nothing. + * + * @param writtenValue Effective written value + */ + void mandatoryVerifyValueChildren(final NormalizedNode writtenValue) { + // Defaults to no-op } @Override - protected TreeNode applyWrite(final ModifiedNode modification, - final Optional currentMeta, final Version version) { - final NormalizedNode newValue = modification.getWrittenValue(); + protected final void recursivelyVerifyStructure(final NormalizedNode value) { + final NormalizedNodeContainer container = (NormalizedNodeContainer) value; + for (final NormalizedNode child : container.getValue()) { + final Optional childOp = getChild(child.getIdentifier()); + if (!childOp.isPresent()) { + throw new SchemaValidationFailedException( + String.format("Node %s is not a valid child of %s according to the schema.", + child.getIdentifier(), container.getIdentifier())); + } + + childOp.get().recursivelyVerifyStructure(child); + } + } + + @Override + protected TreeNode applyWrite(final ModifiedNode modification, final NormalizedNode newValue, + final Optional currentMeta, final Version version) { final TreeNode newValueMeta = TreeNodeFactory.createTreeNode(newValue, version); if (modification.getChildren().isEmpty()) { @@ -88,7 +192,7 @@ abstract class AbstractNodeContainerModificationStrategy extends SchemaAwareAppl mutable.setSubtreeVersion(version); @SuppressWarnings("rawtypes") - final NormalizedNodeContainerBuilder dataBuilder = createBuilder(newValue); + final NormalizedNodeContainerBuilder dataBuilder = support.createBuilder(newValue); final TreeNode result = mutateChildren(mutable, dataBuilder, version, modification.getChildren()); // We are good to go except one detail: this is a single logical write, but @@ -112,10 +216,10 @@ abstract class AbstractNodeContainerModificationStrategy extends SchemaAwareAppl final Version nodeVersion, final Iterable modifications) { for (final ModifiedNode mod : modifications) { - final YangInstanceIdentifier.PathArgument id = mod.getIdentifier(); - final Optional cm = meta.getChild(id); + final PathArgument id = mod.getIdentifier(); + final Optional cm = meta.getChild(id); - final Optional result = resolveChildOperation(id).apply(mod, cm, nodeVersion); + final Optional result = resolveChildOperation(id).apply(mod, cm, nodeVersion); if (result.isPresent()) { final TreeNode tn = result.get(); meta.addChild(tn); @@ -131,12 +235,89 @@ abstract class AbstractNodeContainerModificationStrategy extends SchemaAwareAppl } @Override - protected TreeNode applyMerge(final ModifiedNode modification, final TreeNode currentMeta, - final Version version) { - // For Node Containers - merge is same as subtree change - we only replace children. + protected TreeNode applyMerge(final ModifiedNode modification, final TreeNode currentMeta, final Version version) { + /* + * The node which we are merging exists. We now need to expand any child operations implied by the value. Once + * we do that, ModifiedNode children will look like this node were a TOUCH and we will let applyTouch() do the + * heavy lifting of applying the children recursively (either through here or through applyWrite(). + */ + final NormalizedNode value = modification.getWrittenValue(); + + Verify.verify(value instanceof NormalizedNodeContainer, "Attempted to merge non-container %s", value); + for (final NormalizedNode c : ((NormalizedNodeContainer) value).getValue()) { + final PathArgument id = c.getIdentifier(); + modification.modifyChild(id, resolveChildOperation(id), version); + } return applyTouch(modification, currentMeta, version); } + private void mergeChildrenIntoModification(final ModifiedNode modification, + final Collection> children, final Version version) { + for (final NormalizedNode c : children) { + final ModificationApplyOperation childOp = resolveChildOperation(c.getIdentifier()); + final ModifiedNode childNode = modification.modifyChild(c.getIdentifier(), childOp, version); + childOp.mergeIntoModifiedNode(childNode, c, version); + } + } + + @Override + final void mergeIntoModifiedNode(final ModifiedNode modification, final NormalizedNode value, + final Version version) { + final Collection> children = + ((NormalizedNodeContainer)value).getValue(); + + switch (modification.getOperation()) { + case NONE: + // Fresh node, just record a MERGE with a value + recursivelyVerifyStructure(value); + modification.updateValue(LogicalOperation.MERGE, value); + return; + case TOUCH: + + mergeChildrenIntoModification(modification, children, version); + // We record empty merge value, since real children merges + // are already expanded. This is needed to satisfy non-null for merge + // original merge value can not be used since it mean different + // order of operation - parent changes are always resolved before + // children ones, and having node in TOUCH means children was modified + // before. + modification.updateValue(LogicalOperation.MERGE, support.createEmptyValue(value)); + return; + case MERGE: + // Merging into an existing node. Merge data children modifications (maybe recursively) and mark + // as MERGE, invalidating cached snapshot + mergeChildrenIntoModification(modification, children, version); + modification.updateOperationType(LogicalOperation.MERGE); + return; + case DELETE: + // Delete performs a data dependency check on existence of the node. Performing a merge on DELETE means + // we are really performing a write. One thing that ruins that are any child modifications. If there + // are any, we will perform a read() to get the current state of affairs, turn this into into a WRITE + // and then append any child entries. + if (!modification.getChildren().isEmpty()) { + // Version does not matter here as we'll throw it out + final Optional current = apply(modification, modification.getOriginal(), + Version.initial()); + if (current.isPresent()) { + modification.updateValue(LogicalOperation.WRITE, current.get().getData()); + mergeChildrenIntoModification(modification, children, version); + return; + } + } + + modification.updateValue(LogicalOperation.WRITE, value); + return; + case WRITE: + // We are augmenting a previous write. We'll just walk value's children, get the corresponding + // ModifiedNode and run recursively on it + mergeChildrenIntoModification(modification, children, version); + modification.updateOperationType(LogicalOperation.WRITE); + return; + default: + throw new IllegalArgumentException("Unsupported operation " + modification.getOperation()); + } + } + @Override protected TreeNode applyTouch(final ModifiedNode modification, final TreeNode currentMeta, final Version version) { /* @@ -147,7 +328,7 @@ abstract class AbstractNodeContainerModificationStrategy extends SchemaAwareAppl final Collection children = modification.getChildren(); if (!children.isEmpty()) { @SuppressWarnings("rawtypes") - final NormalizedNodeContainerBuilder dataBuilder = createBuilder(currentMeta.getData()); + final NormalizedNodeContainerBuilder dataBuilder = support.createBuilder(currentMeta.getData()); final MutableTreeNode newMeta = currentMeta.mutable(); newMeta.setSubtreeVersion(version); final TreeNode ret = mutateChildren(newMeta, dataBuilder, version, children); @@ -176,17 +357,49 @@ abstract class AbstractNodeContainerModificationStrategy extends SchemaAwareAppl } @Override - protected void checkTouchApplicable(final YangInstanceIdentifier path, final NodeModification modification, - final Optional current) throws DataValidationFailedException { - if (!modification.getOriginal().isPresent() && !current.isPresent()) { - throw new ModifiedNodeDoesNotExistException(path, String.format("Node %s does not exist. Cannot apply modification to its children.", path)); - } - + protected final void checkTouchApplicable(final ModificationPath path, final NodeModification modification, + final Optional current, final Version version) throws DataValidationFailedException { + final TreeNode currentNode; if (!current.isPresent()) { - throw new ConflictingModificationAppliedException(path, "Node was deleted by other transaction."); + currentNode = defaultTreeNode(); + if (currentNode == null) { + if (!modification.getOriginal().isPresent()) { + final YangInstanceIdentifier id = path.toInstanceIdentifier(); + throw new ModifiedNodeDoesNotExistException(id, + String.format("Node %s does not exist. Cannot apply modification to its children.", id)); + } + + throw new ConflictingModificationAppliedException(path.toInstanceIdentifier(), + "Node was deleted by other transaction."); + } + } else { + currentNode = current.get(); } - checkChildPreconditions(path, modification, current.get()); + checkChildPreconditions(path, modification, currentNode, version); + } + + /** + * Return the default tree node. Default implementation does nothing, but can be overridden to call + * {@link #defaultTreeNode(NormalizedNode)}. + * + * @return Default empty tree node, or null if no default is available + */ + @Nullable TreeNode defaultTreeNode() { + // Defaults to no recovery + return null; + } + + static final TreeNode defaultTreeNode(final NormalizedNode emptyNode) { + return TreeNodeFactory.createTreeNode(emptyNode, FAKE_VERSION); + } + + @Override + protected final void checkMergeApplicable(final ModificationPath path, final NodeModification modification, + final Optional current, final Version version) throws DataValidationFailedException { + if (current.isPresent()) { + checkChildPreconditions(path, modification, current.get(), version); + } } /** @@ -196,28 +409,27 @@ abstract class AbstractNodeContainerModificationStrategy extends SchemaAwareAppl * @param modification current modification * @param current Current data tree node. */ - private void checkChildPreconditions(final YangInstanceIdentifier path, final NodeModification modification, final TreeNode current) throws DataValidationFailedException { + private void checkChildPreconditions(final ModificationPath path, final NodeModification modification, + final TreeNode current, final Version version) throws DataValidationFailedException { for (final NodeModification childMod : modification.getChildren()) { - final YangInstanceIdentifier.PathArgument childId = childMod.getIdentifier(); - final Optional childMeta = current.getChild(childId); + final PathArgument childId = childMod.getIdentifier(); + final Optional childMeta = current.getChild(childId); - final YangInstanceIdentifier childPath = path.node(childId); - resolveChildOperation(childId).checkApplicable(childPath, childMod, childMeta); + path.push(childId); + try { + resolveChildOperation(childId).checkApplicable(path, childMod, childMeta, version); + } finally { + path.pop(); + } } } @Override - protected void checkMergeApplicable(final YangInstanceIdentifier path, final NodeModification modification, - final Optional current) throws DataValidationFailedException { - if (current.isPresent()) { - checkChildPreconditions(path, modification, current.get()); - } + public final String toString() { + return addToStringAttributes(MoreObjects.toStringHelper(this)).toString(); } - protected boolean verifyChildrenStructure() { - return verifyChildrenStructure; + ToStringHelper addToStringAttributes(final ToStringHelper helper) { + return helper.add("support", support).add("verifyChildren", verifyChildrenStructure); } - - @SuppressWarnings("rawtypes") - protected abstract NormalizedNodeContainerBuilder createBuilder(NormalizedNode original); }