HONEYCOMB-431: delegate DataModification.validate to WriterRegistry

This patch introduces ModifiableDataTreeDelegator.validateCandidate
that translates DataTreeCandidate to DataObjectUpdates
and delegates validation to WriterRegistry (similarly as for bulk update).

ModifiableDataTreeManager.commit implementation
invokes validation before bulk update.
To make it efficient, DataObjectUpdates are computed once
and stored in DataTreeContext.

Change-Id: If4bd558e64ed84c11c9c50c7a98a2aaa8db841bb
Signed-off-by: Marek Gradzki <mgradzki@cisco.com>

1 files changed, 78 insertions, 18 deletions

diff --git a/infra/data-impl/src/main/java/io/fd/honeycomb/data/impl/ModifiableDataTreeDelegator.java b/infra/data-impl/src/main/java/io/fd/honeycomb/data/impl/ModifiableDataTreeDelegator.java
index 92c4b393c..b9246f3c4 100644
--- a/infra/data-impl/src/main/java/io/fd/honeycomb/data/impl/ModifiableDataTreeDelegator.java
+++ b/infra/data-impl/src/main/java/io/fd/honeycomb/data/impl/ModifiableDataTreeDelegator.java
@@ -18,6 +18,8 @@ package io.fd.honeycomb.data.impl;
 
 import static com.google.common.base.Preconditions.checkNotNull;
 import static com.google.common.util.concurrent.Futures.immediateCheckedFuture;
+import static io.fd.honeycomb.data.impl.ModifiableDataTreeDelegator.DataTreeWriteContextFactory.DataTreeWriteContext;
+import static io.fd.honeycomb.data.impl.ModifiableDataTreeManager.DataTreeContextFactory.DataTreeContext;
 
 import com.google.common.annotations.VisibleForTesting;
 import com.google.common.base.Optional;
@@ -28,6 +30,7 @@ import io.fd.honeycomb.data.DataModification;
 import io.fd.honeycomb.data.ReadableDataManager;
 import io.fd.honeycomb.translate.MappingContext;
 import io.fd.honeycomb.translate.TranslationException;
+import io.fd.honeycomb.translate.ValidationFailedException;
 import io.fd.honeycomb.translate.util.RWUtils;
 import io.fd.honeycomb.translate.util.TransactionMappingContext;
 import io.fd.honeycomb.translate.util.write.TransactionWriteContext;
@@ -35,6 +38,7 @@ import io.fd.honeycomb.translate.write.DataObjectUpdate;
 import io.fd.honeycomb.translate.write.WriteContext;
 import io.fd.honeycomb.translate.write.registry.UpdateFailedException;
 import io.fd.honeycomb.translate.write.registry.WriterRegistry;
+import io.fd.honeycomb.translate.write.registry.WriterRegistry.DataObjectUpdates;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
@@ -83,7 +87,7 @@ public final class ModifiableDataTreeDelegator extends ModifiableDataTreeManager
                                        @Nonnull final SchemaContext schema,
                                        @Nonnull final WriterRegistry writerRegistry,
                                        @Nonnull final DataBroker contextBroker) {
-        super(dataTree);
+        super(dataTree, new DataTreeWriteContextFactory());
         this.contextBroker = checkNotNull(contextBroker, "contextBroker should not be null");
         this.serializer = checkNotNull(serializer, "serializer should not be null");
         this.writerRegistry = checkNotNull(writerRegistry, "writerRegistry should not be null");
@@ -109,28 +113,50 @@ public final class ModifiableDataTreeDelegator extends ModifiableDataTreeManager
             this.untouchedModification = untouchedModification;
         }
 
-        /**
-         * Pass the changes to underlying writer layer.
-         * Transform from BI to BA.
-         * Revert(Write data before to subtrees that have been successfully modified before failure) in case of failure.
-         */
         @Override
-        protected void processCandidate(final DataTreeCandidate candidate)
-            throws TranslationException {
+        protected void validateCandidate(final DataTreeContext dataTreeContext) throws ValidationFailedException {
+            final DataObjectUpdates baUpdates =
+                getUpdates((DataTreeWriteContextFactory.DataTreeWriteContext) dataTreeContext);
+            LOG.debug("ModifiableDataTreeDelegator.validateCandidate() extracted updates={}", baUpdates);
 
-            final DataTreeCandidateNode rootNode = candidate.getRootNode();
-            final YangInstanceIdentifier rootPath = candidate.getRootPath();
-            LOG.trace("ConfigDataTree.modify() rootPath={}, rootNode={}, dataBefore={}, dataAfter={}",
-                rootPath, rootNode, rootNode.getDataBefore(), rootNode.getDataAfter());
+            try (final WriteContext ctx = getTransactionWriteContext()) {
+                writerRegistry.validateModifications(baUpdates, ctx);
+            }
+        }
 
-            final ModificationDiff modificationDiff = new ModificationDiff.ModificationDiffBuilder()
+        private DataObjectUpdates getUpdates(final DataTreeWriteContext dataTreeContext) {
+            DataObjectUpdates updates = dataTreeContext.getUpdates();
+            if (updates != null) {
+                return updates;
+            } else {
+                final DataTreeCandidate candidate = dataTreeContext.getCandidate();
+                final DataTreeCandidateNode rootNode = candidate.getRootNode();
+                final YangInstanceIdentifier rootPath = candidate.getRootPath();
+                LOG.trace("ConfigDataTree.getUpdates() rootPath={}, rootNode={}, dataBefore={}, dataAfter={}",
+                    rootPath, rootNode, rootNode.getDataBefore(), rootNode.getDataAfter());
+
+                final ModificationDiff modificationDiff = new ModificationDiff.ModificationDiffBuilder()
                     .setCtx(schema).build(rootNode);
-            LOG.debug("ConfigDataTree.modify() diff: {}", modificationDiff);
+                LOG.debug("ConfigDataTree.getUpdates() diff: {}", modificationDiff);
 
-            // Distinguish between updates (create + update) and deletes
-            final WriterRegistry.DataObjectUpdates baUpdates =
-                    toBindingAware(writerRegistry, modificationDiff.getUpdates());
-            LOG.debug("ConfigDataTree.modify() extracted updates={}", baUpdates);
+                // Distinguish between updates (create + update) and deletes
+                updates = toBindingAware(writerRegistry, modificationDiff.getUpdates());
+                dataTreeContext.setUpdates(updates);
+                return updates;
+            }
+        }
+
+        /**
+         * Pass the changes to underlying writer layer. Transform from BI to BA. Revert(Write data before to subtrees
+         * that have been successfully modified before failure) in case of failure.
+         */
+        @Override
+        protected void processCandidate(final DataTreeContext dataTreeContext) throws TranslationException {
+            final DataTreeWriteContextFactory.DataTreeWriteContext dataTreeWriteContext =
+                (DataTreeWriteContextFactory.DataTreeWriteContext) dataTreeContext;
+
+            final DataObjectUpdates baUpdates = dataTreeWriteContext.getUpdates();
+            LOG.debug("ModifiableDataTreeDelegator.processCandidate() extracted updates={}", baUpdates);
 
             final WriteContext ctx = getTransactionWriteContext();
             final MappingContext mappingContext = ctx.getMappingContext();
@@ -297,6 +323,40 @@ public final class ModifiableDataTreeDelegator extends ModifiableDataTreeManager
         return dataObject;
     }
 
+    static final class DataTreeWriteContextFactory implements ModifiableDataTreeManager.DataTreeContextFactory {
+        @Nonnull
+        @Override
+        public DataTreeWriteContext create(@Nonnull final DataTreeCandidate candidate) {
+            return new DataTreeWriteContext(candidate);
+        }
+
+        /**
+         * Implementation of {@link DataTreeContext} that, in addition to {@link DataTreeCandidate}, stores also
+         * {@DataObjectUpdates}. The {@link DataObjectUpdates} are shared by the validation and translation process.
+         */
+        static final class DataTreeWriteContext implements DataTreeContext {
+            private final DataTreeCandidate candidate;
+            private DataObjectUpdates updates;
+
+            DataTreeWriteContext(@Nonnull final DataTreeCandidate candidate) {
+                this.candidate = candidate;
+            }
+
+            @Nonnull
+            @Override
+            public DataTreeCandidate getCandidate() {
+                return candidate;
+            }
+
+            public void setUpdates(@Nonnull final DataObjectUpdates updates) {
+                this.updates = updates;
+            }
+
+            DataObjectUpdates getUpdates() {
+                return updates;
+            }
+        }
+    }
 }