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.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;
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<T extends WithStatus>
+ extends SchemaAwareApplyOperation<T> {
+ abstract static class Invisible<T extends WithStatus> extends AbstractNodeContainerModificationStrategy<T> {
+ private final @NonNull SchemaAwareApplyOperation<T> entryStrategy;
- private final Class<? extends NormalizedNode<?, ?>> nodeClass;
+ Invisible(final NormalizedNodeContainerSupport<?, ?> support, final DataTreeConfiguration treeConfig,
+ final SchemaAwareApplyOperation<T> entryStrategy) {
+ super(support, treeConfig);
+ this.entryStrategy = requireNonNull(entryStrategy);
+ }
+
+ @Override
+ final T getSchema() {
+ return entryStrategy.getSchema();
+ }
+
+ final Optional<ModificationApplyOperation> entryStrategy() {
+ return Optional.of(entryStrategy);
+ }
+
+ @Override
+ ToStringHelper addToStringAttributes(final ToStringHelper helper) {
+ return super.addToStringAttributes(helper).add("entry", entryStrategy);
+ }
+ }
+
+ abstract static class Visible<T extends WithStatus> extends AbstractNodeContainerModificationStrategy<T> {
+ 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<? extends NormalizedNode<?, ?>> 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<ModificationApplyOperation> 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<ModificationApplyOperation> 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);
}
- protected void recursivelyVerifyStructure(NormalizedNode<?, ?> value) {
- final NormalizedNodeContainer container = (NormalizedNodeContainer) value;
- for (final Object child : container.getValue()) {
- checkArgument(child instanceof NormalizedNode);
- final NormalizedNode<?, ?> castedChild = (NormalizedNode<?, ?>) child;
- final Optional<ModificationApplyOperation> childOp = getChild(castedChild.getIdentifier());
- if (childOp.isPresent()) {
- childOp.get().recursivelyVerifyStructure(castedChild);
- } else {
+ /**
+ * 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 final void recursivelyVerifyStructure(final NormalizedNode<?, ?> value) {
+ final NormalizedNodeContainer<?, ?, ?> container = (NormalizedNodeContainer<?, ?, ?>) value;
+ for (final NormalizedNode<?, ?> child : container.getValue()) {
+ final Optional<ModificationApplyOperation> childOp = getChild(child.getIdentifier());
+ if (!childOp.isPresent()) {
throw new SchemaValidationFailedException(
- String.format("Child %s is not valid child according to schema.", castedChild.getIdentifier()));
+ 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 Optional<TreeNode> currentMeta, final Version version) {
- final NormalizedNode<?, ?> newValue = modification.getWrittenValue();
+ protected TreeNode applyWrite(final ModifiedNode modification, final NormalizedNode<?, ?> newValue,
+ final Optional<? extends TreeNode> currentMeta, final Version version) {
final TreeNode newValueMeta = TreeNodeFactory.createTreeNode(newValue, version);
if (modification.getChildren().isEmpty()) {
}
/*
- * 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.
+ *
+ * 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.
+ * 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.
+ * 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
final Version nodeVersion, final Iterable<ModifiedNode> modifications) {
for (final ModifiedNode mod : modifications) {
- final YangInstanceIdentifier.PathArgument id = mod.getIdentifier();
- final Optional<TreeNode> cm = meta.getChild(id);
+ final PathArgument id = mod.getIdentifier();
+ final Optional<? extends TreeNode> cm = meta.getChild(id);
- final Optional<TreeNode> result = resolveChildOperation(id).apply(mod, cm, nodeVersion);
+ final Optional<? extends TreeNode> result = resolveChildOperation(id).apply(mod, cm, nodeVersion);
if (result.isPresent()) {
final TreeNode tn = result.get();
meta.addChild(tn);
final NormalizedNode<?, ?> value = modification.getWrittenValue();
Verify.verify(value instanceof NormalizedNodeContainer, "Attempted to merge non-container %s", value);
- @SuppressWarnings({"unchecked", "rawtypes"})
- final Collection<NormalizedNode<?, ?>> children = ((NormalizedNodeContainer) value).getValue();
- for (NormalizedNode<?, ?> c : children) {
+ for (final NormalizedNode<?, ?> c : ((NormalizedNodeContainer<?, ?, ?>) value).getValue()) {
final PathArgument id = c.getIdentifier();
- modification.modifyChild(id, resolveChildOperation(id).getChildPolicy(), version);
+ modification.modifyChild(id, resolveChildOperation(id), version);
}
return applyTouch(modification, currentMeta, version);
}
private void mergeChildrenIntoModification(final ModifiedNode modification,
- final Collection<NormalizedNode<?, ?>> children, final Version version) {
- for (NormalizedNode<?, ?> c : children) {
+ final Collection<? extends NormalizedNode<?, ?>> children, final Version version) {
+ for (final NormalizedNode<?, ?> c : children) {
final ModificationApplyOperation childOp = resolveChildOperation(c.getIdentifier());
- final ModifiedNode childNode = modification.modifyChild(c.getIdentifier(), childOp.getChildPolicy(), version);
+ 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) {
- @SuppressWarnings({ "unchecked", "rawtypes" })
- final Collection<NormalizedNode<?, ?>> children = ((NormalizedNodeContainer)value).getValue();
+ final Collection<? extends NormalizedNode<?, ?>> children =
+ ((NormalizedNodeContainer<?, ?, ?>)value).getValue();
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<TreeNode> 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<? extends TreeNode> 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;
- }
-
- throw new IllegalArgumentException("Unsupported operation " + modification.getOperation());
- }
- @SuppressWarnings({"rawtypes", "unchecked"})
- private NormalizedNode<?, ?> createEmptyValue(NormalizedNode<?, ?> value,
- Collection<NormalizedNode<?, ?>> children) {
- NormalizedNodeContainerBuilder builder = createBuilder(value);
- for (NormalizedNode<?, ?> child : children) {
- builder.removeChild(child.getIdentifier());
+ 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());
}
- return builder.build();
}
@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<ModifiedNode> 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) {
}
@Override
- protected void checkTouchApplicable(final YangInstanceIdentifier path, final NodeModification modification,
- final Optional<TreeNode> 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<? extends TreeNode> 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);
}
/**
- * 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) throws DataValidationFailedException {
- for (final NodeModification childMod : modification.getChildren()) {
- final YangInstanceIdentifier.PathArgument childId = childMod.getIdentifier();
- final Optional<TreeNode> 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);
- }
+ 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<TreeNode> current) throws DataValidationFailedException {
+ protected final void checkMergeApplicable(final ModificationPath path, final NodeModification modification,
+ final Optional<? extends TreeNode> current, final Version version) throws DataValidationFailedException {
if (current.isPresent()) {
- checkChildPreconditions(path, modification, current.get());
+ 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<? extends TreeNode> childMeta = current.getChild(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);
+ }
}