X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=opendaylight%2Fmd-sal%2Fsal-dom-broker%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fcontroller%2Fmd%2Fsal%2Fdom%2Fstore%2Fimpl%2FSchemaAwareApplyOperation.java;h=00727347eea95f7378ebc53fc9cf97d3cc7fc7f5;hb=f2439a364be2129ab6d50eb15ad2df1a0ecac21f;hp=6308b6f63ebb14dd33191f50d013d012cc8bca58;hpb=bcd020ecbeeacc97df1717a238d93bacd87bcbfc;p=controller.git 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 6308b6f63e..00727347ee 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 @@ -2,16 +2,20 @@ package org.opendaylight.controller.md.sal.dom.store.impl; import static com.google.common.base.Preconditions.checkArgument; +import java.util.Map; import java.util.Set; +import java.util.concurrent.ExecutionException; import org.opendaylight.controller.md.sal.dom.store.impl.tree.ModificationType; 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.data.api.InstanceIdentifier.AugmentationIdentifier; import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeIdentifier; import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeIdentifierWithPredicates; import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeWithValue; import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument; +import org.opendaylight.yangtools.yang.data.api.schema.AugmentationNode; import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode; import org.opendaylight.yangtools.yang.data.api.schema.LeafNode; import org.opendaylight.yangtools.yang.data.api.schema.LeafSetEntryNode; @@ -20,12 +24,17 @@ 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.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.ImmutableChoiceNodeBuilder; import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableContainerNodeBuilder; import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableLeafSetNodeBuilder; import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableMapEntryNodeBuilder; import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableMapNodeBuilder; +import org.opendaylight.yangtools.yang.model.api.AugmentationSchema; +import org.opendaylight.yangtools.yang.model.api.AugmentationTarget; +import org.opendaylight.yangtools.yang.model.api.ChoiceCaseNode; import org.opendaylight.yangtools.yang.model.api.ChoiceNode; import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode; import org.opendaylight.yangtools.yang.model.api.DataNodeContainer; @@ -36,9 +45,10 @@ import org.opendaylight.yangtools.yang.model.api.ListSchemaNode; import com.google.common.base.Function; import com.google.common.base.Optional; -import com.google.common.cache.Cache; 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; @@ -60,11 +70,26 @@ public abstract class SchemaAwareApplyOperation implements ModificationApplyOper throw new IllegalArgumentException("Not supported schema node type for " + schemaNode.getClass()); } - @Override - public Optional getChild(final PathArgument child) { - throw new IllegalArgumentException(); + public static SchemaAwareApplyOperation from(final DataNodeContainer resolvedTree, + final AugmentationTarget augSchemas, final AugmentationIdentifier identifier) { + AugmentationSchema augSchema = null; + allAugments : for (AugmentationSchema potential : augSchemas.getAvailableAugmentations()) { + boolean containsAll = true; + for(DataSchemaNode child : potential.getChildNodes()) { + if(identifier.getPossibleChildNames().contains(child.getQName())) { + augSchema = potential; + break allAugments; + } + } + } + if(augSchema != null) { + return new AugmentationModificationStrategy(augSchema,resolvedTree); + } + return null; } + + protected final ModificationApplyOperation resolveChildOperation(final PathArgument child) { Optional potential = getChild(child); checkArgument(potential.isPresent(), "Operation for child %s is not defined.", child); @@ -123,13 +148,14 @@ public abstract class SchemaAwareApplyOperation implements ModificationApplyOper @Override public final Optional apply(final NodeModification modification, final Optional currentMeta, final UnsignedLong subtreeVersion) { + switch (modification.getModificationType()) { case DELETE: - return Optional.absent(); + return modification.storeSnapshot(Optional.absent()); case SUBTREE_MODIFIED: - return Optional.of(applySubtreeChange(modification, currentMeta.get(), subtreeVersion)); + return modification.storeSnapshot(Optional.of(applySubtreeChange(modification, currentMeta.get(), subtreeVersion))); case WRITE: - return Optional.of(applyWrite(modification, currentMeta, subtreeVersion)); + return modification.storeSnapshot(Optional.of(applyWrite(modification, currentMeta, subtreeVersion))); case UNMODIFIED: return currentMeta; default: @@ -217,13 +243,12 @@ public abstract class SchemaAwareApplyOperation implements ModificationApplyOper this.nodeClass = nodeClass; } - @Override public void verifyStructure(final NodeModification modification) throws IllegalArgumentException { - if(modification.getModificationType() == ModificationType.WRITE) { + if (modification.getModificationType() == ModificationType.WRITE) { } - for(NodeModification childModification : modification.getModifications()) { + for (NodeModification childModification : modification.getModifications()) { resolveChildOperation(childModification.getIdentifier()).verifyStructure(childModification); } } @@ -234,7 +259,7 @@ public abstract class SchemaAwareApplyOperation implements ModificationApplyOper checkArgument(nodeClass.isInstance(writenValue), "Node should must be of type %s", nodeClass); checkArgument(writenValue instanceof NormalizedNodeContainer); NormalizedNodeContainer writenCont = (NormalizedNodeContainer) writenValue; - for(Object child : writenCont.getValue()) { + for (Object child : writenCont.getValue()) { checkArgument(child instanceof NormalizedNode); NormalizedNode childNode = (NormalizedNode) child; } @@ -250,7 +275,7 @@ public abstract class SchemaAwareApplyOperation implements ModificationApplyOper if (currentMeta.isPresent()) { nodeVersion = StoreUtils.increase(currentMeta.get().getNodeVersion()); } - StoreMetadataNode newValueMeta = StoreMetadataNode.createRecursivelly(newValue, nodeVersion, nodeVersion); + StoreMetadataNode newValueMeta = StoreMetadataNode.createRecursively(newValue, nodeVersion, nodeVersion); if (!modification.hasAdditionalModifications()) { return newValueMeta; @@ -277,7 +302,6 @@ public abstract class SchemaAwareApplyOperation implements ModificationApplyOper @SuppressWarnings("rawtypes") NormalizedNodeContainerBuilder dataBuilder = createBuilder(modification.getIdentifier()); StoreNodeCompositeBuilder builder = StoreNodeCompositeBuilder.from(dataBuilder) - // .setIdentifier(modification.getIdentifier()).setNodeVersion(currentMeta.getNodeVersion()) .setSubtreeVersion(updatedSubtreeVersion); // We process preexisting nodes @@ -348,17 +372,21 @@ public abstract class SchemaAwareApplyOperation implements ModificationApplyOper NormalizedNodeContainerModificationStrategy { private final T schema; - private final Cache childCache = CacheBuilder.newBuilder() - .build(CacheLoader.from(new Function() { - - @Override - public ModificationApplyOperation apply(final PathArgument identifier) { - DataSchemaNode child = schema.getDataChildByName(identifier.getNodeType()); - if (child == null || child.isAugmenting()) { - return null; + private final LoadingCache childCache = CacheBuilder.newBuilder().build( + CacheLoader.from(new Function() { + + @Override + public ModificationApplyOperation apply(final PathArgument identifier) { + if (identifier instanceof AugmentationIdentifier && schema instanceof AugmentationTarget) { + return from(schema, (AugmentationTarget) schema, (AugmentationIdentifier) identifier); + } + + DataSchemaNode child = schema.getDataChildByName(identifier.getNodeType()); + if (child == null) { + return null; + } + return from(child); } - return from(child); - } })); protected DataNodeContainerModificationStrategy(final T schema, @@ -373,11 +401,11 @@ public abstract class SchemaAwareApplyOperation implements ModificationApplyOper @Override public Optional getChild(final PathArgument identifier) { - DataSchemaNode child = schema.getDataChildByName(identifier.getNodeType()); - if (child == null || child.isAugmenting()) { + try { + return Optional. fromNullable(childCache.get(identifier)); + } catch (ExecutionException e) { return Optional.absent(); } - return Optional. of(from(child)); } @Override @@ -408,20 +436,52 @@ public abstract class SchemaAwareApplyOperation implements ModificationApplyOper } + public static class AugmentationModificationStrategy extends + DataNodeContainerModificationStrategy { + + protected AugmentationModificationStrategy(final AugmentationSchema schema, final DataNodeContainer resolved) { + super(schema, AugmentationNode.class); + // FIXME: Use resolved children instead of unresolved. + + } + + + @Override + protected DataContainerNodeBuilder createBuilder(final PathArgument identifier) { + return Builders.augmentationBuilder().withNodeIdentifier((AugmentationIdentifier) identifier); + } + + } + public static class ChoiceModificationStrategy extends NormalizedNodeContainerModificationStrategy { private final ChoiceNode schema; + private final Map childNodes; public ChoiceModificationStrategy(final ChoiceNode schemaNode) { super(org.opendaylight.yangtools.yang.data.api.schema.ChoiceNode.class); this.schema = schemaNode; + ImmutableMap.Builder child = ImmutableMap.builder(); + + for(ChoiceCaseNode caze : schemaNode.getCases()) { + for(DataSchemaNode cazeChild : caze.getChildNodes()) { + SchemaAwareApplyOperation childNode = from(cazeChild); + child.put(new NodeIdentifier(cazeChild.getQName()),childNode); + } + } + childNodes = child.build(); + } + + @Override + public Optional getChild(final PathArgument child) { + return Optional.fromNullable(childNodes.get(child)); } @Override @SuppressWarnings("rawtypes") protected DataContainerNodeBuilder createBuilder(final PathArgument identifier) { checkArgument(identifier instanceof NodeIdentifier); - return ImmutableContainerNodeBuilder.create().withNodeIdentifier((NodeIdentifier) identifier); + return ImmutableChoiceNodeBuilder.create().withNodeIdentifier((NodeIdentifier) identifier); } }