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%2Fsal%2Fdom%2Fbroker%2Fimpl%2FSchemaAwareDataStoreAdapter.java;h=0120231f8de8f02a10da51ef1d2b068c36afe147;hb=bf8cca4f590ce0a8bece21f0f1a81f6823ee3d65;hp=1f908140b0ba60ca286095e4c693804609ec3472;hpb=144c567aa78ca4f6ea6279163b3a8ba8d5de0dc2;p=controller.git

diff --git a/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/sal/dom/broker/impl/SchemaAwareDataStoreAdapter.java b/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/sal/dom/broker/impl/SchemaAwareDataStoreAdapter.java
index 1f908140b0..0120231f8d 100644
--- a/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/sal/dom/broker/impl/SchemaAwareDataStoreAdapter.java
+++ b/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/sal/dom/broker/impl/SchemaAwareDataStoreAdapter.java
@@ -1,27 +1,27 @@
 package org.opendaylight.controller.sal.dom.broker.impl;
 
-import java.awt.PageAttributes.OriginType;
 import java.util.ArrayList;
-import java.util.Collections;
 import java.util.Comparator;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Map;
 import java.util.Map.Entry;
-import java.util.Set;
-import java.util.concurrent.atomic.AtomicLong;
+import java.util.concurrent.Future;
 
+import org.opendaylight.controller.md.sal.common.api.TransactionStatus;
 import org.opendaylight.controller.md.sal.common.api.data.DataModification;
 import org.opendaylight.controller.md.sal.common.api.data.DataReader;
+import org.opendaylight.controller.md.sal.common.impl.AbstractDataModification;
 import org.opendaylight.controller.md.sal.common.impl.util.AbstractLockableDelegator;
 import org.opendaylight.controller.sal.core.api.data.DataStore;
-import org.opendaylight.controller.sal.core.api.model.SchemaServiceListener;
+import org.opendaylight.controller.sal.dom.broker.util.YangSchemaUtils;
+import org.opendaylight.yangtools.yang.model.api.SchemaServiceListener;
 import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.common.RpcResult;
 import org.opendaylight.yangtools.yang.data.api.CompositeNode;
 import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
 import org.opendaylight.yangtools.yang.data.api.Node;
 import org.opendaylight.yangtools.yang.data.impl.CompositeNodeTOImpl;
+import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.controller.sal.dom.broker.util.YangDataOperations;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -39,7 +39,6 @@ public class SchemaAwareDataStoreAdapter extends AbstractLockableDelegator<DataS
 
     private SchemaContext schema = null;
     private boolean validationEnabled = false;
-    private SchemaAwareDataMerger dataMerger = null;
     private DataReader<InstanceIdentifier, CompositeNode> reader = new MergeFirstLevelReader();
 
     @Override
@@ -100,7 +99,8 @@ public class SchemaAwareDataStoreAdapter extends AbstractLockableDelegator<DataS
     public org.opendaylight.controller.md.sal.common.api.data.DataCommitHandler.DataCommitTransaction<InstanceIdentifier, CompositeNode> requestCommit(
             DataModification<InstanceIdentifier, CompositeNode> modification) {
         validateAgainstSchema(modification);
-        DataModification<InstanceIdentifier, CompositeNode> cleanedUp = prepareMergedTransaction(modification);
+        NormalizedDataModification cleanedUp = prepareMergedTransaction(modification);
+        cleanedUp.status = TransactionStatus.SUBMITED;
         return retrieveDelegate().requestCommit(cleanedUp);
     }
 
@@ -118,7 +118,7 @@ public class SchemaAwareDataStoreAdapter extends AbstractLockableDelegator<DataS
         }
 
         if (schema == null) {
-            LOG.info("Validation not performed for {}. Reason: YANG Schema not present.", modification.getIdentifier());
+            LOG.warn("Validation not performed for {}. Reason: YANG Schema not present.", modification.getIdentifier());
             return;
         }
     }
@@ -138,10 +138,40 @@ public class SchemaAwareDataStoreAdapter extends AbstractLockableDelegator<DataS
         this.schema = null;
     }
 
-    private DataModification<InstanceIdentifier, CompositeNode> prepareMergedTransaction(
+    protected CompositeNode mergeData(InstanceIdentifier path, CompositeNode stored, CompositeNode modified,
+            boolean config) {
+        long startTime = System.nanoTime();
+        try {
+            DataSchemaNode node = schemaNodeFor(path);
+            return YangDataOperations.merge(node, stored, modified, config);
+        } finally {
+            // System.out.println("Merge time: " + ((System.nanoTime() -
+            // startTime) / 1000.0d));
+        }
+    }
+
+    private DataSchemaNode schemaNodeFor(InstanceIdentifier path) {
+        checkState(schema != null, "YANG Schema is not available");
+        return YangSchemaUtils.getSchemaNode(schema, path);
+    }
+
+    private NormalizedDataModification prepareMergedTransaction(
             DataModification<InstanceIdentifier, CompositeNode> original) {
         // NOOP for now
-        return original;
+        NormalizedDataModification normalized = new NormalizedDataModification(original);
+        for (Entry<InstanceIdentifier, CompositeNode> entry : original.getUpdatedConfigurationData().entrySet()) {
+            normalized.putConfigurationData(entry.getKey(), entry.getValue());
+        }
+        for (Entry<InstanceIdentifier, CompositeNode> entry : original.getUpdatedOperationalData().entrySet()) {
+            normalized.putOperationalData(entry.getKey(), entry.getValue());
+        }
+        for (InstanceIdentifier entry : original.getRemovedConfigurationData()) {
+            normalized.removeConfigurationData(entry);
+        }
+        for (InstanceIdentifier entry : original.getRemovedOperationalData()) {
+            normalized.removeOperationalData(entry);
+        }
+        return normalized;
     }
 
     private final Comparator<Entry<InstanceIdentifier, CompositeNode>> preparationComparator = new Comparator<Entry<InstanceIdentifier, CompositeNode>>() {
@@ -242,4 +272,44 @@ public class SchemaAwareDataStoreAdapter extends AbstractLockableDelegator<DataS
             }
         }
     }
+
+    private class NormalizedDataModification extends AbstractDataModification<InstanceIdentifier, CompositeNode> {
+
+        private Object identifier;
+        private TransactionStatus status;
+
+        public NormalizedDataModification(DataModification<InstanceIdentifier, CompositeNode> original) {
+            super(getDelegate());
+            identifier = original;
+            status = TransactionStatus.NEW;
+        }
+
+        @Override
+        public Object getIdentifier() {
+            return this.identifier;
+        }
+
+        @Override
+        public TransactionStatus getStatus() {
+            return status;
+        }
+
+        @Override
+        public Future<RpcResult<TransactionStatus>> commit() {
+            throw new UnsupportedOperationException("Commit should not be invoked on this");
+        }
+
+        @Override
+        protected CompositeNode mergeConfigurationData(InstanceIdentifier path, CompositeNode stored,
+                CompositeNode modified) {
+            return mergeData(path, stored, modified, true);
+        }
+
+        @Override
+        protected CompositeNode mergeOperationalData(InstanceIdentifier path, CompositeNode stored,
+                CompositeNode modified) {
+            return mergeData(path, stored, modified, false);
+        }
+    }
+
 }