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=2accd980be0c37f4213497f8db10ecc841a3ec05;hb=a7c0733bc9201f67b73196d93792dee582f931fd;hp=f908483b409a22cb54f0a0476c4b90873322316b;hpb=8db9e47c66243774ad4291dcbed9012e70f33503;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 f908483b40..2accd980be 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,81 +8,163 @@ 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.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.DistinctNodeContainer; 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.builder.NormalizedNodeContainerBuilder; 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; -import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeConfiguration; import org.opendaylight.yangtools.yang.data.api.schema.tree.TreeType; -import org.opendaylight.yangtools.yang.data.api.schema.tree.spi.MutableTreeNode; -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.spi.tree.MutableTreeNode; +import org.opendaylight.yangtools.yang.data.spi.tree.TreeNode; +import org.opendaylight.yangtools.yang.data.spi.tree.TreeNodeFactory; +import org.opendaylight.yangtools.yang.data.spi.tree.Version; +import org.opendaylight.yangtools.yang.model.api.DocumentedNode.WithStatus; + +abstract class AbstractNodeContainerModificationStrategy + extends SchemaAwareApplyOperation { + abstract static class Invisible extends AbstractNodeContainerModificationStrategy { + private final @NonNull SchemaAwareApplyOperation entryStrategy; + + 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 @NonNull ModificationApplyOperation entryStrategy() { + return entryStrategy; + } + + @Override + ToStringHelper addToStringAttributes(final ToStringHelper helper) { + return super.addToStringAttributes(helper).add("entry", entryStrategy); + } + } -abstract class AbstractNodeContainerModificationStrategy extends SchemaAwareApplyOperation { + 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 Class> nodeClass; + private final NormalizedNodeContainerSupport support; private final boolean verifyChildrenStructure; - protected AbstractNodeContainerModificationStrategy(final Class> nodeClass, + AbstractNodeContainerModificationStrategy(final NormalizedNodeContainerSupport support, final DataTreeConfiguration treeConfig) { - this.nodeClass = Preconditions.checkNotNull(nodeClass , "nodeClass"); - this.verifyChildrenStructure = (treeConfig.getTreeType() == TreeType.CONFIGURATION); + 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()); - if (childOp.isPresent()) { - childOp.get().verifyStructure(castedChild, verifyChildren); - } else { + } + + @Override + final void verifyValueChildren(final NormalizedNode writtenValue) { + if (verifyChildrenStructure) { + final DistinctNodeContainer container = (DistinctNodeContainer) writtenValue; + for (final NormalizedNode child : container.body()) { + final ModificationApplyOperation childOp = childByArg(child.getIdentifier()); + if (childOp == null) { throw new SchemaValidationFailedException(String.format( - "Node %s is not a valid child of %s according to the schema.", - castedChild.getIdentifier(), container.getIdentifier())); + "Node %s is not a valid child of %s according to the schema.", + child.getIdentifier(), container.getIdentifier())); } + childOp.fullVerifyStructure(child); } + + 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 void recursivelyVerifyStructure(final NormalizedNode value) { - final NormalizedNodeContainer container = (NormalizedNodeContainer) value; - for (final Object child : container.getValue()) { - checkArgument(child instanceof NormalizedNode); - final NormalizedNode castedChild = (NormalizedNode) child; - final Optional childOp = getChild(castedChild.getIdentifier()); - if (childOp.isPresent()) { - childOp.get().recursivelyVerifyStructure(castedChild); - } else { + protected final void recursivelyVerifyStructure(final NormalizedNode value) { + final NormalizedNodeContainer container = (NormalizedNodeContainer) value; + for (final NormalizedNode child : container.body()) { + final ModificationApplyOperation childOp = childByArg(child.getIdentifier()); + if (childOp == null) { throw new SchemaValidationFailedException( - String.format("Node %s is not a valid child of %s according to the schema.", - castedChild.getIdentifier(), container.getIdentifier())); + String.format("Node %s is not a valid child of %s according to the schema.", + child.getIdentifier(), container.getIdentifier())); } + + childOp.recursivelyVerifyStructure(child); } } @Override - protected TreeNode applyWrite(final ModifiedNode modification, - final Optional currentMeta, final Version version) { - final NormalizedNode newValue = modification.getWrittenValue(); + 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()) { @@ -90,26 +172,24 @@ abstract class AbstractNodeContainerModificationStrategy extends SchemaAwareAppl } /* - * 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. + * 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 and apply the operations on top of the written value. * - * 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. + * We could have done it during the write, but this operation is potentially expensive, so we have left it out + * of the fast path. * - * FIXME: this code needs to be moved out from the prepare() path and into - * the read() and seal() paths. Merging of writes needs to be charged - * to the code which originated this, not to the code which is - * attempting to make it visible. + * 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. + * + * FIXME: this code needs to be moved out from the prepare() path and into the read() and seal() paths. Merging + * of writes needs to be charged to the code which originated this, not to the code which is attempting + * to make it visible. */ final MutableTreeNode mutable = newValueMeta.mutable(); 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 @@ -133,13 +213,13 @@ 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.findChildByArg(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); + meta.putChild(tn); data.addChild(tn.getData()); } else { meta.removeChild(id); @@ -158,12 +238,10 @@ abstract class AbstractNodeContainerModificationStrategy extends SchemaAwareAppl * 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(); + final NormalizedNode value = modification.getWrittenValue(); - Verify.verify(value instanceof NormalizedNodeContainer, "Attempted to merge non-container %s", value); - @SuppressWarnings({"unchecked", "rawtypes"}) - final Collection> children = ((NormalizedNodeContainer) value).getValue(); - for (final NormalizedNode c : children) { + Verify.verify(value instanceof DistinctNodeContainer, "Attempted to merge non-container %s", value); + for (final NormalizedNode c : ((DistinctNodeContainer) value).body()) { final PathArgument id = c.getIdentifier(); modification.modifyChild(id, resolveChildOperation(id), version); } @@ -171,8 +249,8 @@ abstract class AbstractNodeContainerModificationStrategy extends SchemaAwareAppl } private void mergeChildrenIntoModification(final ModifiedNode modification, - final Collection> children, final Version version) { - for (final NormalizedNode c : children) { + 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); @@ -180,84 +258,83 @@ abstract class AbstractNodeContainerModificationStrategy extends SchemaAwareAppl } @Override - final void mergeIntoModifiedNode(final ModifiedNode modification, final NormalizedNode value, + final void mergeIntoModifiedNode(final ModifiedNode modification, final NormalizedNode value, final Version version) { - @SuppressWarnings({ "unchecked", "rawtypes" }) - final Collection> children = ((NormalizedNodeContainer)value).getValue(); - + final Collection children = ((DistinctNodeContainer)value).body(); switch (modification.getOperation()) { - case NONE: - // Fresh node, just record a MERGE with a value + case NONE: + // Fresh node, just record a MERGE with a value recursivelyVerifyStructure(value); - modification.updateValue(LogicalOperation.MERGE, value); - return; - case TOUCH: + 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, createEmptyValue(value)); + // 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); + 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; + 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; + 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()); } - - throw new IllegalArgumentException("Unsupported operation " + modification.getOperation()); } @Override protected TreeNode applyTouch(final ModifiedNode modification, final TreeNode currentMeta, final Version version) { /* - * The user may have issued an empty merge operation. In this case we do not perform - * a data tree mutation, do not pass GO, and do not collect useless garbage. It - * also means the ModificationType is UNMODIFIED. + * The user may have issued an empty merge operation. In this case we: + * - do not perform a data tree mutation + * - do not pass GO, and + * - do not collect useless garbage. + * It also means the ModificationType is UNMODIFIED. */ 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); /* - * It is possible that the only modifications under this node were empty merges, - * which were turned into UNMODIFIED. If that is the case, we can turn this operation - * into UNMODIFIED, too, potentially cascading it up to root. This has the benefit - * of speeding up any users, who can skip processing child nodes. + * It is possible that the only modifications under this node were empty merges, which were turned into + * UNMODIFIED. If that is the case, we can turn this operation into UNMODIFIED, too, potentially cascading + * it up to root. This has the benefit of speeding up any users, who can skip processing child nodes. * * In order to do that, though, we have to check all child operations are UNMODIFIED. + * * Let's do precisely that, stopping as soon we find a different result. */ for (final ModifiedNode child : children) { @@ -275,51 +352,75 @@ abstract class AbstractNodeContainerModificationStrategy extends SchemaAwareAppl } @Override - protected void checkTouchApplicable(final YangInstanceIdentifier path, final NodeModification modification, - final Optional current, final Version version) 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(), version); + checkChildPreconditions(path, modification, currentNode, version); } /** - * Recursively check child preconditions. + * Return the default tree node. Default implementation does nothing, but can be overridden to call + * {@link #defaultTreeNode(NormalizedNode)}. * - * @param path current node path - * @param modification current modification - * @param current Current data tree node. + * @return Default empty tree node, or null if no default is available */ - private void checkChildPreconditions(final YangInstanceIdentifier 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); + @Nullable TreeNode defaultTreeNode() { + // Defaults to no recovery + return null; + } - final YangInstanceIdentifier childPath = path.node(childId); - resolveChildOperation(childId).checkApplicable(childPath, childMod, childMeta, version); - } + static final TreeNode defaultTreeNode(final NormalizedNode emptyNode) { + return TreeNodeFactory.createTreeNode(emptyNode, FAKE_VERSION); } @Override - protected void checkMergeApplicable(final YangInstanceIdentifier path, final NodeModification modification, - final Optional current, final Version version) throws DataValidationFailedException { + 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); } } - protected boolean verifyChildrenStructure() { - return verifyChildrenStructure; + /** + * Recursively check child preconditions. + * + * @param path current node path + * @param modification current modification + * @param current Current data tree node. + */ + private void checkChildPreconditions(final ModificationPath path, final NodeModification modification, + final TreeNode current, final Version version) throws DataValidationFailedException { + for (final NodeModification childMod : modification.getChildren()) { + final PathArgument childId = childMod.getIdentifier(); + final Optional childMeta = current.findChildByArg(childId); + + path.push(childId); + try { + resolveChildOperation(childId).checkApplicable(path, childMod, childMeta, version); + } finally { + path.pop(); + } + } } - @SuppressWarnings("rawtypes") - protected abstract NormalizedNodeContainerBuilder createBuilder(NormalizedNode original); - - protected abstract NormalizedNode createEmptyValue(NormalizedNode original); + @Override + ToStringHelper addToStringAttributes(final ToStringHelper helper) { + return helper.add("support", support).add("verifyChildren", verifyChildrenStructure); + } }