X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?p=controller.git;a=blobdiff_plain;f=opendaylight%2Fmd-sal%2Fsal-dom-broker%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fcontroller%2Fmd%2Fsal%2Fdom%2Fstore%2Fimpl%2FSchemaAwareApplyOperation.java;h=2af522ea861791fcae324f2f5761b258d93b8845;hp=7ea4d4e09fc1590557b339b65ce78a8fb54f25c6;hb=8022ea0892ef0499580685b12bc130f29ae8bbbc;hpb=02e3bf52dc3c0fe8f4c87a170419926ee6d72f33 diff --git a/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/md/sal/dom/store/impl/SchemaAwareApplyOperation.java b/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/md/sal/dom/store/impl/SchemaAwareApplyOperation.java index 7ea4d4e09f..2af522ea86 100644 --- a/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/md/sal/dom/store/impl/SchemaAwareApplyOperation.java +++ b/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/md/sal/dom/store/impl/SchemaAwareApplyOperation.java @@ -1,3 +1,10 @@ +/* + * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ package org.opendaylight.controller.md.sal.dom.store.impl; import static com.google.common.base.Preconditions.checkArgument; @@ -13,6 +20,7 @@ import org.opendaylight.controller.md.sal.dom.store.impl.tree.NodeModification; import org.opendaylight.controller.md.sal.dom.store.impl.tree.StoreMetadataNode; import org.opendaylight.controller.md.sal.dom.store.impl.tree.StoreNodeCompositeBuilder; import org.opendaylight.yangtools.yang.common.QName; +import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier; import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.AugmentationIdentifier; import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeIdentifier; import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeIdentifierWithPredicates; @@ -27,11 +35,12 @@ import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode; import org.opendaylight.yangtools.yang.data.api.schema.MapNode; 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.OrderedLeafSetNode; import org.opendaylight.yangtools.yang.data.api.schema.OrderedMapNode; import org.opendaylight.yangtools.yang.data.api.schema.UnkeyedListEntryNode; -import org.opendaylight.yangtools.yang.data.impl.schema.Builders; import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeBuilder; import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.NormalizedNodeContainerBuilder; +import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableAugmentationNodeBuilder; import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableChoiceNodeBuilder; import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableContainerNodeBuilder; import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableLeafSetNodeBuilder; @@ -59,8 +68,6 @@ import com.google.common.cache.CacheBuilder; import com.google.common.cache.CacheLoader; import com.google.common.cache.LoadingCache; import com.google.common.collect.ImmutableMap; -import com.google.common.collect.ImmutableSet; -import com.google.common.collect.ImmutableSet.Builder; import com.google.common.primitives.UnsignedLong; public abstract class SchemaAwareApplyOperation implements ModificationApplyOperation { @@ -135,55 +142,52 @@ public abstract class SchemaAwareApplyOperation implements ModificationApplyOper protected abstract void verifyWritenStructure(NormalizedNode writenValue); @Override - public boolean isApplicable(final NodeModification modification, final Optional current) { + public void checkApplicable(final InstanceIdentifier path,final NodeModification modification, final Optional current) throws DataPreconditionFailedException { switch (modification.getModificationType()) { case DELETE: - return isDeleteApplicable(modification, current); + checkDeleteApplicable(modification, current); case SUBTREE_MODIFIED: - return isSubtreeModificationApplicable(modification, current); + checkSubtreeModificationApplicable(path,modification, current); + return; case WRITE: - return isWriteApplicable(modification, current); + checkWriteApplicable(path,modification, current); + return; case MERGE: - return isMergeApplicable(modification,current); + checkMergeApplicable(path,modification,current); + return; case UNMODIFIED: - return true; + return; default: - return false; + throw new UnsupportedOperationException("Suplied modification type "+modification.getModificationType()+ "is not supported."); } + } - private boolean isMergeApplicable(final NodeModification modification, final Optional current) { + protected void checkMergeApplicable(final InstanceIdentifier path,final NodeModification modification, final Optional current) throws DataPreconditionFailedException { Optional original = modification.getOriginal(); if (original.isPresent() && current.isPresent()) { - return isNotConflicting(original.get(), current.get()); - } else if (current.isPresent()) { - return true; + checkNotConflicting(path,original.get(), current.get()); } - return true; } - protected boolean isWriteApplicable(final NodeModification modification, final Optional current) { + protected void checkWriteApplicable(final InstanceIdentifier path,final NodeModification modification, final Optional current) throws DataPreconditionFailedException { Optional original = modification.getOriginal(); if (original.isPresent() && current.isPresent()) { - return isNotConflicting(original.get(), current.get()); - } else if (current.isPresent()) { - return false; + checkNotConflicting(path,original.get(), current.get()); + } else if(original.isPresent()) { + throw new DataPreconditionFailedException(path,"Node was deleted by other transaction."); } - return true; - } - protected final boolean isNotConflicting(final StoreMetadataNode original, final StoreMetadataNode current) { - return original.getNodeVersion().equals(current.getNodeVersion()) - && original.getSubtreeVersion().equals(current.getSubtreeVersion()); + protected static final void checkNotConflicting(final InstanceIdentifier path,final StoreMetadataNode original, final StoreMetadataNode current) throws DataPreconditionFailedException { + checkDataPrecondition(path, original.getNodeVersion().equals(current.getNodeVersion()),"Node was replaced by other transaction."); + checkDataPrecondition(path,original.getSubtreeVersion().equals(current.getSubtreeVersion()), "Node children was modified by other transaction"); } - protected abstract boolean isSubtreeModificationApplicable(final NodeModification modification, - final Optional current); + protected abstract void checkSubtreeModificationApplicable(InstanceIdentifier path,final NodeModification modification, + final Optional current) throws DataPreconditionFailedException; - private boolean isDeleteApplicable(final NodeModification modification, final Optional current) { - // FiXME: Add delete conflict detection. - return true; + private void checkDeleteApplicable(final NodeModification modification, final Optional current) { } @Override @@ -265,9 +269,9 @@ public abstract class SchemaAwareApplyOperation implements ModificationApplyOper } @Override - protected boolean isSubtreeModificationApplicable(final NodeModification modification, - final Optional current) { - return false; + protected void checkSubtreeModificationApplicable(final InstanceIdentifier path,final NodeModification modification, + final Optional current) throws DataPreconditionFailedException { + throw new DataPreconditionFailedException(path, "Subtree modification is not allowed."); } } @@ -306,6 +310,14 @@ public abstract class SchemaAwareApplyOperation implements ModificationApplyOper } } + @Override + protected void checkWriteApplicable(final InstanceIdentifier path, final NodeModification modification, + final Optional current) throws DataPreconditionFailedException { + // FIXME: Implement proper write check for replacement of node container + // prerequisite is to have transaction chain available for clients + // otherwise this will break chained writes to same node. + } + @SuppressWarnings("rawtypes") @Override protected void verifyWritenStructure(final NormalizedNode writenValue) { @@ -321,30 +333,28 @@ public abstract class SchemaAwareApplyOperation implements ModificationApplyOper @Override protected StoreMetadataNode applyWrite(final NodeModification modification, final Optional currentMeta, final UnsignedLong subtreeVersion) { - // + NormalizedNode newValue = modification.getWritenValue(); - UnsignedLong nodeVersion = subtreeVersion; + final UnsignedLong nodeVersion; if (currentMeta.isPresent()) { nodeVersion = StoreUtils.increase(currentMeta.get().getNodeVersion()); + } else { + nodeVersion = subtreeVersion; } - StoreMetadataNode newValueMeta = StoreMetadataNode.createRecursively(newValue, nodeVersion, nodeVersion); + final StoreMetadataNode newValueMeta = StoreMetadataNode.createRecursively(newValue, nodeVersion, nodeVersion); if (!modification.hasAdditionalModifications()) { return newValueMeta; } + @SuppressWarnings("rawtypes") - NormalizedNodeContainerBuilder dataBuilder = createBuilder(modification.getIdentifier()); + NormalizedNodeContainerBuilder dataBuilder = createBuilder(newValue); StoreNodeCompositeBuilder builder = StoreNodeCompositeBuilder.from(dataBuilder) // .setNodeVersion(nodeVersion) // .setSubtreeVersion(subtreeVersion); - Set processedPreexisting = applyPreexistingChildren(modification, newValueMeta.getChildren(), - builder, nodeVersion); - applyNewChildren(modification, processedPreexisting, builder, nodeVersion); - - return builder.build(); - + return mutateChildren(modification.getModifications(), newValueMeta, builder, nodeVersion); } @Override @@ -357,75 +367,64 @@ public abstract class SchemaAwareApplyOperation implements ModificationApplyOper @Override public StoreMetadataNode applySubtreeChange(final NodeModification modification, final StoreMetadataNode currentMeta, final UnsignedLong subtreeVersion) { + // Bump subtree version to its new target + final UnsignedLong updatedSubtreeVersion = StoreUtils.increase(currentMeta.getSubtreeVersion()); - UnsignedLong updatedSubtreeVersion = StoreUtils.increase(currentMeta.getSubtreeVersion()); @SuppressWarnings("rawtypes") - NormalizedNodeContainerBuilder dataBuilder = createBuilder(modification.getIdentifier()); - StoreNodeCompositeBuilder builder = StoreNodeCompositeBuilder.from(dataBuilder) + NormalizedNodeContainerBuilder dataBuilder = createBuilder(currentMeta.getData()); + StoreNodeCompositeBuilder builder = StoreNodeCompositeBuilder.from(dataBuilder, currentMeta) .setIdentifier(modification.getIdentifier()).setNodeVersion(currentMeta.getNodeVersion()) .setSubtreeVersion(updatedSubtreeVersion); - // We process preexisting nodes - Set processedPreexisting = applyPreexistingChildren(modification, currentMeta.getChildren(), - builder, updatedSubtreeVersion); - applyNewChildren(modification, processedPreexisting, builder, updatedSubtreeVersion); - return builder.build(); + + return mutateChildren(modification.getModifications(), currentMeta, builder, updatedSubtreeVersion); } - private void applyNewChildren(final NodeModification modification, final Set ignore, - final StoreNodeCompositeBuilder builder, final UnsignedLong subtreeVersion) { - for (NodeModification childModification : modification.getModifications()) { - PathArgument childIdentifier = childModification.getIdentifier(); - // We skip allready processed modifications - if (ignore.contains(childIdentifier)) { - continue; - } + private StoreMetadataNode mutateChildren(final Iterable modifications, final StoreMetadataNode meta, + final StoreNodeCompositeBuilder builder, final UnsignedLong nodeVersion) { - builder.addIfPresent(resolveChildOperation(childIdentifier) // - .apply(childModification, Optional. absent(), subtreeVersion)); - } - } + for (NodeModification mod : modifications) { + final PathArgument id = mod.getIdentifier(); + final Optional cm = meta.getChild(id); - private Set applyPreexistingChildren(final NodeModification modification, - final Iterable children, final StoreNodeCompositeBuilder nodeBuilder, - final UnsignedLong subtreeVersion) { - Builder processedModifications = ImmutableSet. builder(); - for (StoreMetadataNode childMeta : children) { - PathArgument childIdentifier = childMeta.getIdentifier(); - // We retrieve Child modification metadata - Optional childModification = modification.getChild(childIdentifier); - // Node is modified - if (childModification.isPresent()) { - processedModifications.add(childIdentifier); - Optional result = resolveChildOperation(childIdentifier) // - .apply(childModification.get(), Optional.of(childMeta), subtreeVersion); - nodeBuilder.addIfPresent(result); + Optional result = resolveChildOperation(id).apply(mod, cm, nodeVersion); + if (result.isPresent()) { + builder.add(result.get()); } else { - // Child is unmodified - reuse existing metadata and data - // snapshot - nodeBuilder.add(childMeta); + builder.remove(id); } } - return processedModifications.build(); + + return builder.build(); } @Override - protected boolean isSubtreeModificationApplicable(final NodeModification modification, - final Optional current) { - if (false == current.isPresent()) { - return false; - } - boolean result = true; + protected void checkSubtreeModificationApplicable(final InstanceIdentifier path,final NodeModification modification, + final Optional current) throws DataPreconditionFailedException { + checkDataPrecondition(path, current.isPresent(), "Node was deleted by other transaction."); + checkChildPreconditions(path,modification,current); + + } + + private void checkChildPreconditions(final InstanceIdentifier path, final NodeModification modification, final Optional current) throws DataPreconditionFailedException { StoreMetadataNode currentMeta = current.get(); for (NodeModification childMod : modification.getModifications()) { PathArgument childId = childMod.getIdentifier(); Optional childMeta = currentMeta.getChild(childId); - result &= resolveChildOperation(childId).isApplicable(childMod, childMeta); + InstanceIdentifier childPath = StoreUtils.append(path, childId); + resolveChildOperation(childId).checkApplicable(childPath,childMod, childMeta); + } + } + + @Override + protected void checkMergeApplicable(final InstanceIdentifier path, final NodeModification modification, + final Optional current) throws DataPreconditionFailedException { + if(current.isPresent()) { + checkChildPreconditions(path,modification,current); } - return result; } @SuppressWarnings("rawtypes") - protected abstract NormalizedNodeContainerBuilder createBuilder(PathArgument identifier); + protected abstract NormalizedNodeContainerBuilder createBuilder(NormalizedNode original); } public static abstract class DataNodeContainerModificationStrategy extends @@ -470,7 +469,7 @@ public abstract class SchemaAwareApplyOperation implements ModificationApplyOper @Override @SuppressWarnings("rawtypes") - protected abstract DataContainerNodeBuilder createBuilder(PathArgument identifier); + protected abstract DataContainerNodeBuilder createBuilder(NormalizedNode original); @Override public String toString() { @@ -488,12 +487,10 @@ public abstract class SchemaAwareApplyOperation implements ModificationApplyOper @Override @SuppressWarnings("rawtypes") - protected DataContainerNodeBuilder createBuilder(final PathArgument identifier) { - // TODO Auto-generated method stub - checkArgument(identifier instanceof NodeIdentifier); - return ImmutableContainerNodeBuilder.create().withNodeIdentifier((NodeIdentifier) identifier); + protected DataContainerNodeBuilder createBuilder(final NormalizedNode original) { + checkArgument(original instanceof ContainerNode); + return ImmutableContainerNodeBuilder.create((ContainerNode) original); } - } public static class UnkeyedListItemModificationStrategy extends @@ -505,11 +502,10 @@ public abstract class SchemaAwareApplyOperation implements ModificationApplyOper @Override @SuppressWarnings("rawtypes") - protected DataContainerNodeBuilder createBuilder(final PathArgument identifier) { - checkArgument(identifier instanceof NodeIdentifier); - return ImmutableUnkeyedListEntryNodeBuilder.create().withNodeIdentifier((NodeIdentifier) identifier); + protected DataContainerNodeBuilder createBuilder(final NormalizedNode original) { + checkArgument(original instanceof UnkeyedListEntryNode); + return ImmutableUnkeyedListEntryNodeBuilder.create((UnkeyedListEntryNode) original); } - } public static class AugmentationModificationStrategy extends @@ -517,15 +513,14 @@ public abstract class SchemaAwareApplyOperation implements ModificationApplyOper protected AugmentationModificationStrategy(final AugmentationSchema schema, final DataNodeContainer resolved) { super(createAugmentProxy(schema,resolved), AugmentationNode.class); - // FIXME: Use resolved children instead of unresolved. - } @Override - protected DataContainerNodeBuilder createBuilder(final PathArgument identifier) { - return Builders.augmentationBuilder().withNodeIdentifier((AugmentationIdentifier) identifier); + @SuppressWarnings("rawtypes") + protected DataContainerNodeBuilder createBuilder(final NormalizedNode original) { + checkArgument(original instanceof AugmentationNode); + return ImmutableAugmentationNodeBuilder.create((AugmentationNode) original); } - } public static class ChoiceModificationStrategy extends NormalizedNodeContainerModificationStrategy { @@ -554,11 +549,10 @@ public abstract class SchemaAwareApplyOperation implements ModificationApplyOper @Override @SuppressWarnings("rawtypes") - protected DataContainerNodeBuilder createBuilder(final PathArgument identifier) { - checkArgument(identifier instanceof NodeIdentifier); - return ImmutableChoiceNodeBuilder.create().withNodeIdentifier((NodeIdentifier) identifier); + protected DataContainerNodeBuilder createBuilder(final NormalizedNode original) { + checkArgument(original instanceof org.opendaylight.yangtools.yang.data.api.schema.ChoiceNode); + return ImmutableChoiceNodeBuilder.create((org.opendaylight.yangtools.yang.data.api.schema.ChoiceNode) original); } - } public static class ListEntryModificationStrategy extends DataNodeContainerModificationStrategy { @@ -569,10 +563,10 @@ public abstract class SchemaAwareApplyOperation implements ModificationApplyOper @Override @SuppressWarnings("rawtypes") - protected final DataContainerNodeBuilder createBuilder(final PathArgument identifier) { - return ImmutableMapEntryNodeBuilder.create().withNodeIdentifier((NodeIdentifierWithPredicates) identifier); + protected final DataContainerNodeBuilder createBuilder(final NormalizedNode original) { + checkArgument(original instanceof MapEntryNode); + return ImmutableMapEntryNodeBuilder.create((MapEntryNode) original); } - } public static class UnorderedLeafSetModificationStrategy extends NormalizedNodeContainerModificationStrategy { @@ -587,8 +581,9 @@ public abstract class SchemaAwareApplyOperation implements ModificationApplyOper @SuppressWarnings("rawtypes") @Override - protected NormalizedNodeContainerBuilder createBuilder(final PathArgument identifier) { - return ImmutableLeafSetNodeBuilder.create().withNodeIdentifier((NodeIdentifier) identifier); + protected NormalizedNodeContainerBuilder createBuilder(final NormalizedNode original) { + checkArgument(original instanceof LeafSetNode); + return ImmutableLeafSetNodeBuilder.create((LeafSetNode) original); } @Override @@ -598,7 +593,6 @@ public abstract class SchemaAwareApplyOperation implements ModificationApplyOper } return Optional.absent(); } - } public static class OrderedLeafSetModificationStrategy extends NormalizedNodeContainerModificationStrategy { @@ -613,8 +607,9 @@ public abstract class SchemaAwareApplyOperation implements ModificationApplyOper @SuppressWarnings("rawtypes") @Override - protected NormalizedNodeContainerBuilder createBuilder(final PathArgument identifier) { - return ImmutableOrderedLeafSetNodeBuilder.create().withNodeIdentifier((NodeIdentifier) identifier); + protected NormalizedNodeContainerBuilder createBuilder(final NormalizedNode original) { + checkArgument(original instanceof OrderedLeafSetNode); + return ImmutableOrderedLeafSetNodeBuilder.create((OrderedLeafSetNode) original); } @Override @@ -624,7 +619,6 @@ public abstract class SchemaAwareApplyOperation implements ModificationApplyOper } return Optional.absent(); } - } public static class UnkeyedListModificationStrategy extends SchemaAwareApplyOperation { @@ -667,9 +661,9 @@ public abstract class SchemaAwareApplyOperation implements ModificationApplyOper } @Override - protected boolean isSubtreeModificationApplicable(final NodeModification modification, - final Optional current) { - return false; + protected void checkSubtreeModificationApplicable(final InstanceIdentifier path,final NodeModification modification, + final Optional current) throws DataPreconditionFailedException { + throw new DataPreconditionFailedException(path, "Subtree modification is not allowed."); } } @@ -685,8 +679,9 @@ public abstract class SchemaAwareApplyOperation implements ModificationApplyOper @SuppressWarnings("rawtypes") @Override - protected NormalizedNodeContainerBuilder createBuilder(final PathArgument identifier) { - return ImmutableMapNodeBuilder.create().withNodeIdentifier((NodeIdentifier) identifier); + protected NormalizedNodeContainerBuilder createBuilder(final NormalizedNode original) { + checkArgument(original instanceof MapNode); + return ImmutableMapNodeBuilder.create((MapNode) original); } @Override @@ -714,8 +709,9 @@ public abstract class SchemaAwareApplyOperation implements ModificationApplyOper @SuppressWarnings("rawtypes") @Override - protected NormalizedNodeContainerBuilder createBuilder(final PathArgument identifier) { - return ImmutableOrderedMapNodeBuilder.create().withNodeIdentifier((NodeIdentifier) identifier); + protected NormalizedNodeContainerBuilder createBuilder(final NormalizedNode original) { + checkArgument(original instanceof OrderedMapNode); + return ImmutableOrderedMapNodeBuilder.create((OrderedMapNode) original); } @Override @@ -744,4 +740,11 @@ public abstract class SchemaAwareApplyOperation implements ModificationApplyOper return new AugmentationSchemaProxy(schema, realChildSchemas); } + public static boolean checkDataPrecondition(final InstanceIdentifier path, final boolean condition, final String message) throws DataPreconditionFailedException { + if(!condition) { + throw new DataPreconditionFailedException(path, message); + } + return condition; + } + }