+/*
+ * 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.sal.dom.broker.impl;
-import java.awt.PageAttributes.OriginType;
+import static com.google.common.base.Preconditions.checkState;
+
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.YangDataOperations;
+import org.opendaylight.controller.sal.dom.broker.util.YangSchemaUtils;
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.yangtools.yang.model.api.SchemaServiceListener;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.google.common.base.Predicate;
import com.google.common.collect.FluentIterable;
-
-import static com.google.common.base.Preconditions.*;
+import com.google.common.collect.ImmutableSet;
public class SchemaAwareDataStoreAdapter extends AbstractLockableDelegator<DataStore> implements //
DataStore, //
private SchemaContext schema = null;
private boolean validationEnabled = false;
- private SchemaAwareDataMerger dataMerger = null;
- private DataReader<InstanceIdentifier, CompositeNode> reader = new MergeFirstLevelReader();
+ private final DataReader<InstanceIdentifier, CompositeNode> reader = new MergeFirstLevelReader();
@Override
public boolean containsConfigurationPath(InstanceIdentifier path) {
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);
}
}
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;
}
}
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.deepRemoveConfigurationData(entry);
+ }
+ for (InstanceIdentifier entry : original.getRemovedOperationalData()) {
+ normalized.deepRemoveOperationalData(entry);
+ }
+ return normalized;
+ }
+
+ private Iterable<InstanceIdentifier> getConfigurationSubpaths(InstanceIdentifier entry) {
+ // FIXME: This should be replaced by index
+ Iterable<InstanceIdentifier> paths = getStoredConfigurationPaths();
+
+ return getChildrenPaths(entry, paths);
+
+ }
+
+ public Iterable<InstanceIdentifier> getOperationalSubpaths(InstanceIdentifier entry) {
+ // FIXME: This should be indexed
+ Iterable<InstanceIdentifier> paths = getStoredOperationalPaths();
+
+ return getChildrenPaths(entry, paths);
+ }
+
+ private static final Iterable<InstanceIdentifier> getChildrenPaths(InstanceIdentifier entry,
+ Iterable<InstanceIdentifier> paths) {
+ ImmutableSet.Builder<InstanceIdentifier> children = ImmutableSet.builder();
+ for (InstanceIdentifier potential : paths) {
+ if (entry.contains(potential)) {
+ children.add(entry);
+ }
+ }
+ return children.build();
}
private final Comparator<Entry<InstanceIdentifier, CompositeNode>> preparationComparator = new Comparator<Entry<InstanceIdentifier, CompositeNode>>() {
}
}
}
+
+ private class NormalizedDataModification extends AbstractDataModification<InstanceIdentifier, CompositeNode> {
+
+ private final Object identifier;
+ private TransactionStatus status;
+
+ public NormalizedDataModification(DataModification<InstanceIdentifier, CompositeNode> original) {
+ super(getDelegate());
+ identifier = original;
+ status = TransactionStatus.NEW;
+ }
+
+ /**
+ *
+ * Ensures all subpaths are removed - this currently does slow lookup in
+ * all keys.
+ *
+ * @param entry
+ */
+ public void deepRemoveOperationalData(InstanceIdentifier entry) {
+ Iterable<InstanceIdentifier> paths = getOperationalSubpaths(entry);
+ removeOperationalData(entry);
+ for (InstanceIdentifier potential : paths) {
+ removeOperationalData(potential);
+ }
+ }
+
+ public void deepRemoveConfigurationData(InstanceIdentifier entry) {
+ Iterable<InstanceIdentifier> paths = getConfigurationSubpaths(entry);
+ removeConfigurationData(entry);
+ for (InstanceIdentifier potential : paths) {
+ removeConfigurationData(potential);
+ }
+ }
+
+ @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);
+ }
+ }
+
}
Code Review / controller.git / blobdiff