From 727bbddb5f4a98ed8e97d353ddcf0d339f4e303b Mon Sep 17 00:00:00 2001 From: Tony Tkacik Date: Mon, 23 Jun 2014 09:28:51 +0200 Subject: [PATCH] Bug 1073: Extracted Implementation of Binding Transaction Extracted implementation of Binding Transactions to package private classes, so they could be used by alternative implementation of Broker or TransactionChain. Change-Id: I66825fef8217f2d55f4e987fc8e170d3c447a008 Signed-off-by: Tony Tkacik --- .../impl/AbstractForwardedTransaction.java | 211 ++---------------- .../impl/AbstractReadWriteTransaction.java | 89 ++++++++ .../impl/AbstractWriteTransaction.java | 67 ++++++ .../impl/BindingDataReadTransactionImpl.java | 38 ++++ .../BindingDataReadWriteTransactionImpl.java | 32 +++ .../impl/BindingDataWriteTransactionImpl.java | 53 +++++ .../impl/BindingToNormalizedNodeCodec.java | 79 +++++-- ...orwardedBackwardsCompatibleDataBroker.java | 19 +- .../impl/ForwardedBindingDataBroker.java | 103 +-------- 9 files changed, 373 insertions(+), 318 deletions(-) create mode 100644 opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/md/sal/binding/impl/AbstractReadWriteTransaction.java create mode 100644 opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/md/sal/binding/impl/AbstractWriteTransaction.java create mode 100644 opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/md/sal/binding/impl/BindingDataReadTransactionImpl.java create mode 100644 opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/md/sal/binding/impl/BindingDataReadWriteTransactionImpl.java create mode 100644 opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/md/sal/binding/impl/BindingDataWriteTransactionImpl.java diff --git a/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/md/sal/binding/impl/AbstractForwardedTransaction.java b/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/md/sal/binding/impl/AbstractForwardedTransaction.java index 3fac0dc93a..e5e1e300c1 100644 --- a/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/md/sal/binding/impl/AbstractForwardedTransaction.java +++ b/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/md/sal/binding/impl/AbstractForwardedTransaction.java @@ -7,220 +7,55 @@ */ package org.opendaylight.controller.md.sal.binding.impl; -import java.util.ArrayList; -import java.util.EnumMap; -import java.util.Iterator; -import java.util.List; -import java.util.Map.Entry; -import java.util.concurrent.ExecutionException; -import java.util.concurrent.TimeUnit; - -import javax.annotation.Nullable; - -import org.opendaylight.controller.md.sal.common.api.TransactionStatus; import org.opendaylight.controller.md.sal.common.api.data.AsyncTransaction; import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; -import org.opendaylight.controller.md.sal.common.impl.util.compat.DataNormalizationException; -import org.opendaylight.controller.md.sal.common.impl.util.compat.DataNormalizationOperation; import org.opendaylight.controller.md.sal.dom.api.DOMDataReadTransaction; -import org.opendaylight.controller.md.sal.dom.api.DOMDataReadWriteTransaction; -import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction; import org.opendaylight.yangtools.concepts.Delegator; +import org.opendaylight.yangtools.concepts.Identifiable; import org.opendaylight.yangtools.yang.binding.DataObject; -import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; -import org.opendaylight.yangtools.yang.common.RpcResult; -import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument; +import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier; import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode; -import org.opendaylight.yangtools.yang.data.impl.codec.DeserializationException; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; -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.base.Preconditions; import com.google.common.util.concurrent.Futures; import com.google.common.util.concurrent.ListenableFuture; -public class AbstractForwardedTransaction>> - implements Delegator { - private static final Logger LOG = LoggerFactory.getLogger(AbstractForwardedTransaction.class); +abstract class AbstractForwardedTransaction>> + implements Delegator, Identifiable { + private final T delegate; - private final static CacheBuilder CACHE_BUILDER = CacheBuilder.newBuilder() - .expireAfterWrite(10, TimeUnit.MILLISECONDS).maximumSize(100); private final BindingToNormalizedNodeCodec codec; - private final EnumMap, DataObject>> cacheMap; - protected AbstractForwardedTransaction(final T delegate, final BindingToNormalizedNodeCodec codec) { - super(); - this.delegate = delegate; - this.codec = codec; + public AbstractForwardedTransaction(final T delegateTx, final BindingToNormalizedNodeCodec codec) { + this.delegate = Preconditions.checkNotNull(delegateTx, "Delegate must not be null"); + this.codec = Preconditions.checkNotNull(codec, "Codec must not be null"); + } - this.cacheMap = new EnumMap<>(LogicalDatastoreType.class); - cacheMap.put(LogicalDatastoreType.OPERATIONAL, CACHE_BUILDER., DataObject> build()); - cacheMap.put(LogicalDatastoreType.CONFIGURATION, CACHE_BUILDER., DataObject> build()); + @Override + public final Object getIdentifier() { + return delegate.getIdentifier(); } @Override - public T getDelegate() { + public final T getDelegate() { return delegate; } - protected final BindingToNormalizedNodeCodec getCodec() { - return codec; - } - - protected ListenableFuture> transformFuture(final LogicalDatastoreType store, - final InstanceIdentifier path, final ListenableFuture>> future) { - return Futures.transform(future, new Function>, Optional>() { - @Nullable - @Override - public Optional apply(@Nullable final Optional> normalizedNode) { - if (normalizedNode.isPresent()) { - final DataObject dataObject; - try { - dataObject = codec.toBinding(path, normalizedNode.get()); - } catch (DeserializationException e) { - LOG.warn("Failed to create dataobject from node {}", normalizedNode.get(), e); - throw new IllegalStateException("Failed to create dataobject", e); - } - - if (dataObject != null) { - updateCache(store, path, dataObject); - return Optional.of(dataObject); - } - } - return Optional.absent(); - } - }); - } - - protected void doPut(final DOMDataWriteTransaction writeTransaction, final LogicalDatastoreType store, - final InstanceIdentifier path, final DataObject data) { - invalidateCache(store, path); - final Entry> normalized = codec - .toNormalizedNode(path, data); - writeTransaction.put(store, normalized.getKey(), normalized.getValue()); - } - - protected void doPutWithEnsureParents(final DOMDataReadWriteTransaction writeTransaction, - final LogicalDatastoreType store, final InstanceIdentifier path, final DataObject data) { - invalidateCache(store, path); - final Entry> normalized = codec - .toNormalizedNode(path, data); - - final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier normalizedPath = normalized.getKey(); - ensureParentsByMerge(writeTransaction, store, normalizedPath, path); - LOG.debug("Tx: {} : Putting data {}", getDelegate().getIdentifier(), normalizedPath); - writeTransaction.put(store, normalizedPath, normalized.getValue()); - } - - protected void doMergeWithEnsureParents(final DOMDataReadWriteTransaction writeTransaction, - final LogicalDatastoreType store, final InstanceIdentifier path, final DataObject data) { - invalidateCache(store, path); - final Entry> normalized = codec - .toNormalizedNode(path, data); - - final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier normalizedPath = normalized.getKey(); - ensureParentsByMerge(writeTransaction, store, normalizedPath, path); - LOG.debug("Tx: {} : Merge data {}",getDelegate().getIdentifier(),normalizedPath); - writeTransaction.merge(store, normalizedPath, normalized.getValue()); + @SuppressWarnings("unchecked") + protected final >> S getDelegateChecked(final Class txType) { + Preconditions.checkState(txType.isInstance(delegate)); + return (S) delegate; } - private void ensureParentsByMerge(final DOMDataReadWriteTransaction writeTransaction, - final LogicalDatastoreType store, - final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier normalizedPath, - final InstanceIdentifier path) { - List currentArguments = new ArrayList<>(); - DataNormalizationOperation currentOp = codec.getDataNormalizer().getRootOperation(); - Iterator iterator = normalizedPath.getPath().iterator(); - while (iterator.hasNext()) { - PathArgument currentArg = iterator.next(); - try { - currentOp = currentOp.getChild(currentArg); - } catch (DataNormalizationException e) { - throw new IllegalArgumentException(String.format("Invalid child encountered in path %s", path), e); - } - currentArguments.add(currentArg); - org.opendaylight.yangtools.yang.data.api.InstanceIdentifier currentPath = new org.opendaylight.yangtools.yang.data.api.InstanceIdentifier( - currentArguments); - - final Optional> d; - try { - d = writeTransaction.read(store, currentPath).get(); - } catch (InterruptedException | ExecutionException e) { - LOG.error("Failed to read pre-existing data from store {} path {}", store, currentPath, e); - throw new IllegalStateException("Failed to read pre-existing data", e); - } - - if (!d.isPresent() && iterator.hasNext()) { - writeTransaction.merge(store, currentPath, currentOp.createDefault(currentArg)); - } - } - } - - protected void doMerge(final DOMDataWriteTransaction writeTransaction, final LogicalDatastoreType store, - final InstanceIdentifier path, final DataObject data) { - invalidateCache(store, path); - final Entry> normalized = codec - .toNormalizedNode(path, data); - writeTransaction.merge(store, normalized.getKey(), normalized.getValue()); - } - - protected void doDelete(final DOMDataWriteTransaction writeTransaction, final LogicalDatastoreType store, - final InstanceIdentifier path) { - invalidateCache(store, path); - final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier normalized = codec.toNormalized(path); - writeTransaction.delete(store, normalized); - } - - protected ListenableFuture> doCommit(final DOMDataWriteTransaction writeTransaction) { - return writeTransaction.commit(); - } - - protected boolean doCancel(final DOMDataWriteTransaction writeTransaction) { - return writeTransaction.cancel(); - } - - protected ListenableFuture> doRead(final DOMDataReadTransaction readTransaction, - final LogicalDatastoreType store, final InstanceIdentifier path) { - final DataObject dataObject = getFromCache(store, path); - if (dataObject == null) { - final ListenableFuture>> future = readTransaction.read(store, - codec.toNormalized(path)); - return transformFuture(store, path, future); - } else { - return Futures.immediateFuture(Optional.of(dataObject)); - } - } - - private DataObject getFromCache(final LogicalDatastoreType store, final InstanceIdentifier path) { - Cache, DataObject> cache = cacheMap.get(store); - if (cache != null) { - return cache.getIfPresent(path); - } - return null; - } - - private void updateCache(final LogicalDatastoreType store, final InstanceIdentifier path, - final DataObject dataObject) { - // Check if cache exists. If not create one. - Cache, DataObject> cache = cacheMap.get(store); - if (cache == null) { - cache = CacheBuilder.newBuilder().maximumSize(1000).expireAfterWrite(1, TimeUnit.MINUTES).build(); - - } - - cache.put(path, dataObject); + protected final BindingToNormalizedNodeCodec getCodec() { + return codec; } - private void invalidateCache(final LogicalDatastoreType store, final InstanceIdentifier path) { - // FIXME: Optimization: invalidate only parents and children of path - Cache, DataObject> cache = cacheMap.get(store); - cache.invalidateAll(); - LOG.trace("Cache invalidated"); + protected final ListenableFuture> doRead(final DOMDataReadTransaction readTx, + final LogicalDatastoreType store, final org.opendaylight.yangtools.yang.binding.InstanceIdentifier path) { + return Futures.transform(readTx.read(store, codec.toNormalized(path)), codec.deserializeFunction(path)); } - } diff --git a/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/md/sal/binding/impl/AbstractReadWriteTransaction.java b/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/md/sal/binding/impl/AbstractReadWriteTransaction.java new file mode 100644 index 0000000000..3988bc6960 --- /dev/null +++ b/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/md/sal/binding/impl/AbstractReadWriteTransaction.java @@ -0,0 +1,89 @@ +/* + * 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.binding.impl; + +import java.util.ArrayList; +import java.util.Iterator; +import java.util.List; +import java.util.Map.Entry; +import java.util.concurrent.ExecutionException; + +import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; +import org.opendaylight.controller.md.sal.common.impl.util.compat.DataNormalizationException; +import org.opendaylight.controller.md.sal.common.impl.util.compat.DataNormalizationOperation; +import org.opendaylight.controller.md.sal.dom.api.DOMDataReadWriteTransaction; +import org.opendaylight.yangtools.yang.binding.DataObject; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; +import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument; +import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.Optional; + +public class AbstractReadWriteTransaction extends AbstractWriteTransaction { + + private static final Logger LOG = LoggerFactory.getLogger(AbstractReadWriteTransaction.class); + + public AbstractReadWriteTransaction(final DOMDataReadWriteTransaction delegate, final BindingToNormalizedNodeCodec codec) { + super(delegate, codec); + } + + protected final void doPutWithEnsureParents(final LogicalDatastoreType store, final InstanceIdentifier path, final DataObject data) { + final Entry> normalized = getCodec() + .toNormalizedNode(path, data); + + final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier normalizedPath = normalized.getKey(); + ensureParentsByMerge(store, normalizedPath, path); + LOG.debug("Tx: {} : Putting data {}", getDelegate().getIdentifier(), normalizedPath); + doPut(store, path, data); + } + + protected final void doMergeWithEnsureParents(final LogicalDatastoreType store, final InstanceIdentifier path, final DataObject data) { + final Entry> normalized = getCodec() + .toNormalizedNode(path, data); + + final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier normalizedPath = normalized.getKey(); + ensureParentsByMerge(store, normalizedPath, path); + LOG.debug("Tx: {} : Merge data {}", getDelegate().getIdentifier(), normalizedPath); + doMerge(store, path, data); + } + + private final void ensureParentsByMerge(final LogicalDatastoreType store, + final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier normalizedPath, + final InstanceIdentifier path) { + List currentArguments = new ArrayList<>(); + DataNormalizationOperation currentOp = getCodec().getDataNormalizer().getRootOperation(); + Iterator iterator = normalizedPath.getPathArguments().iterator(); + while (iterator.hasNext()) { + PathArgument currentArg = iterator.next(); + try { + currentOp = currentOp.getChild(currentArg); + } catch (DataNormalizationException e) { + throw new IllegalArgumentException(String.format("Invalid child encountered in path %s", path), e); + } + currentArguments.add(currentArg); + org.opendaylight.yangtools.yang.data.api.InstanceIdentifier currentPath = org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.create( + currentArguments); + + final Optional> d; + try { + d = getDelegate().read(store, currentPath).get(); + } catch (InterruptedException | ExecutionException e) { + LOG.error("Failed to read pre-existing data from store {} path {}", store, currentPath, e); + throw new IllegalStateException("Failed to read pre-existing data", e); + } + + if (!d.isPresent() && iterator.hasNext()) { + getDelegate().merge(store, currentPath, currentOp.createDefault(currentArg)); + } + } + } + + +} diff --git a/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/md/sal/binding/impl/AbstractWriteTransaction.java b/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/md/sal/binding/impl/AbstractWriteTransaction.java new file mode 100644 index 0000000000..5ce66874b1 --- /dev/null +++ b/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/md/sal/binding/impl/AbstractWriteTransaction.java @@ -0,0 +1,67 @@ +/* + * 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.binding.impl; + +import java.util.Map.Entry; + +import org.opendaylight.controller.md.sal.common.api.TransactionStatus; +import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; +import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction; +import org.opendaylight.yangtools.yang.binding.DataObject; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; +import org.opendaylight.yangtools.yang.common.RpcResult; +import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.util.concurrent.ListenableFuture; + +/** + * + * Abstract Base Transaction for transactions which are backed by + * {@link DOMDataWriteTransaction} + */ +public class AbstractWriteTransaction extends + AbstractForwardedTransaction { + + private static final Logger LOG = LoggerFactory.getLogger(AbstractWriteTransaction.class); + + protected AbstractWriteTransaction(final T delegate, + final BindingToNormalizedNodeCodec codec) { + super(delegate, codec); + } + + protected final void doPut(final LogicalDatastoreType store, + final InstanceIdentifier path, final DataObject data) { + final Entry> normalized = getCodec() + .toNormalizedNode(path, data); + getDelegate().put(store, normalized.getKey(), normalized.getValue()); + } + + protected final void doMerge(final LogicalDatastoreType store, + final InstanceIdentifier path, final DataObject data) { + final Entry> normalized = getCodec() + .toNormalizedNode(path, data); + getDelegate().merge(store, normalized.getKey(), normalized.getValue()); + } + + protected final void doDelete(final LogicalDatastoreType store, + final InstanceIdentifier path) { + final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier normalized = getCodec().toNormalized(path); + getDelegate().delete(store, normalized); + } + + protected final ListenableFuture> doCommit() { + return getDelegate().commit(); + } + + protected final boolean doCancel() { + return getDelegate().cancel(); + } + +} diff --git a/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/md/sal/binding/impl/BindingDataReadTransactionImpl.java b/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/md/sal/binding/impl/BindingDataReadTransactionImpl.java new file mode 100644 index 0000000000..e71404dfa4 --- /dev/null +++ b/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/md/sal/binding/impl/BindingDataReadTransactionImpl.java @@ -0,0 +1,38 @@ +/* + * 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.binding.impl; + +import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction; +import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; +import org.opendaylight.controller.md.sal.dom.api.DOMDataReadOnlyTransaction; +import org.opendaylight.yangtools.yang.binding.DataObject; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +import com.google.common.base.Optional; +import com.google.common.util.concurrent.ListenableFuture; + +class BindingDataReadTransactionImpl extends AbstractForwardedTransaction implements + ReadOnlyTransaction { + + protected BindingDataReadTransactionImpl(final DOMDataReadOnlyTransaction delegate, + final BindingToNormalizedNodeCodec codec) { + super(delegate, codec); + } + + @Override + public ListenableFuture> read(final LogicalDatastoreType store, + final InstanceIdentifier path) { + return doRead(getDelegate(),store, path); + } + + @Override + public void close() { + getDelegate().close(); + } + +} \ No newline at end of file diff --git a/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/md/sal/binding/impl/BindingDataReadWriteTransactionImpl.java b/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/md/sal/binding/impl/BindingDataReadWriteTransactionImpl.java new file mode 100644 index 0000000000..5a89cc70b8 --- /dev/null +++ b/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/md/sal/binding/impl/BindingDataReadWriteTransactionImpl.java @@ -0,0 +1,32 @@ +/* + * 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.binding.impl; + +import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction; +import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; +import org.opendaylight.controller.md.sal.dom.api.DOMDataReadWriteTransaction; +import org.opendaylight.yangtools.yang.binding.DataObject; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +import com.google.common.base.Optional; +import com.google.common.util.concurrent.ListenableFuture; + +class BindingDataReadWriteTransactionImpl extends + BindingDataWriteTransactionImpl implements ReadWriteTransaction { + + protected BindingDataReadWriteTransactionImpl(final DOMDataReadWriteTransaction delegate, + final BindingToNormalizedNodeCodec codec) { + super(delegate, codec); + } + + @Override + public ListenableFuture> read(final LogicalDatastoreType store, + final InstanceIdentifier path) { + return doRead(getDelegate(), store, path); + } +} \ No newline at end of file diff --git a/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/md/sal/binding/impl/BindingDataWriteTransactionImpl.java b/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/md/sal/binding/impl/BindingDataWriteTransactionImpl.java new file mode 100644 index 0000000000..a62319be22 --- /dev/null +++ b/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/md/sal/binding/impl/BindingDataWriteTransactionImpl.java @@ -0,0 +1,53 @@ +/* + * 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.binding.impl; + +import org.opendaylight.controller.md.sal.binding.api.WriteTransaction; +import org.opendaylight.controller.md.sal.common.api.TransactionStatus; +import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; +import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction; +import org.opendaylight.yangtools.yang.binding.DataObject; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; +import org.opendaylight.yangtools.yang.common.RpcResult; + +import com.google.common.util.concurrent.ListenableFuture; + +class BindingDataWriteTransactionImpl extends + AbstractWriteTransaction implements WriteTransaction { + + protected BindingDataWriteTransactionImpl(final T delegateTx, final BindingToNormalizedNodeCodec codec) { + super(delegateTx, codec); + } + + + + @Override + public void put(final LogicalDatastoreType store, final InstanceIdentifier path, final DataObject data) { + doPut(store, path, data); + } + + @Override + public void merge(final LogicalDatastoreType store, final InstanceIdentifier path, final DataObject data) { + doMerge(store, path, data); + } + + @Override + public void delete(final LogicalDatastoreType store, final InstanceIdentifier path) { + doDelete( store, path); + } + + @Override + public ListenableFuture> commit() { + return doCommit(); + } + + @Override + public boolean cancel() { + return doCancel(); + } +} \ No newline at end of file diff --git a/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/md/sal/binding/impl/BindingToNormalizedNodeCodec.java b/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/md/sal/binding/impl/BindingToNormalizedNodeCodec.java index f1be5c6922..003f57cd72 100644 --- a/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/md/sal/binding/impl/BindingToNormalizedNodeCodec.java +++ b/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/md/sal/binding/impl/BindingToNormalizedNodeCodec.java @@ -14,6 +14,8 @@ import java.util.LinkedList; import java.util.List; import java.util.Map.Entry; +import javax.annotation.Nullable; + import org.opendaylight.controller.md.sal.common.impl.util.compat.DataNormalizationException; import org.opendaylight.controller.md.sal.common.impl.util.compat.DataNormalizationOperation; import org.opendaylight.controller.md.sal.common.impl.util.compat.DataNormalizer; @@ -42,7 +44,9 @@ import org.opendaylight.yangtools.yang.model.api.SchemaContextListener; import org.slf4j.Logger; import org.slf4j.LoggerFactory; +import com.google.common.base.Function; import com.google.common.base.Optional; +import com.google.common.base.Preconditions; import com.google.common.base.Supplier; import com.google.common.collect.ImmutableList; import com.google.common.collect.Iterables; @@ -75,7 +79,7 @@ public class BindingToNormalizedNodeCodec implements SchemaContextListener { public Entry> toNormalizedNode( final InstanceIdentifier bindingPath, final DataObject bindingObject) { - return toNormalizedNode(toEntry(bindingPath, bindingObject)); + return toNormalizedNode(toBindingEntry(bindingPath, bindingObject)); } @@ -87,17 +91,16 @@ public class BindingToNormalizedNodeCodec implements SchemaContextListener { .toNormalized(legacyEntry); LOG.trace("Serialization of {}, Legacy Representation: {}, Normalized Representation: {}", binding, legacyEntry, normalizedEntry); - if (Augmentation.class.isAssignableFrom(binding.getKey().getTargetType())) { + if (isAugmentation(binding.getKey().getTargetType())) { for (DataContainerChild child : ((DataContainerNode) normalizedEntry .getValue()).getValue()) { if (child instanceof AugmentationNode) { ImmutableList childArgs = ImmutableList. builder() - .addAll(normalizedEntry.getKey().getPath()).add(child.getIdentifier()).build(); - org.opendaylight.yangtools.yang.data.api.InstanceIdentifier childPath = new org.opendaylight.yangtools.yang.data.api.InstanceIdentifier( + .addAll(normalizedEntry.getKey().getPathArguments()).add(child.getIdentifier()).build(); + org.opendaylight.yangtools.yang.data.api.InstanceIdentifier childPath = org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.create( childArgs); - return new SimpleEntry>( - childPath, child); + return toDOMEntry(childPath, child); } } @@ -119,7 +122,7 @@ public class BindingToNormalizedNodeCodec implements SchemaContextListener { final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier normalized) throws DeserializationException { - PathArgument lastArgument = Iterables.getLast(normalized.getPath()); + PathArgument lastArgument = Iterables.getLast(normalized.getPathArguments()); // Used instance-identifier codec do not support serialization of last // path // argument if it is AugmentationIdentifier (behaviour expected by old @@ -143,7 +146,7 @@ public class BindingToNormalizedNodeCodec implements SchemaContextListener { } int normalizedCount = getAugmentationCount(normalized); - AugmentationIdentifier lastArgument = (AugmentationIdentifier) Iterables.getLast(normalized.getPath()); + AugmentationIdentifier lastArgument = (AugmentationIdentifier) Iterables.getLast(normalized.getPathArguments()); // Here we employ small trick - Binding-aware Codec injects an pointer // to augmentation class @@ -152,7 +155,7 @@ public class BindingToNormalizedNodeCodec implements SchemaContextListener { LOG.trace("Looking for candidates to match {}", normalized); for (QName child : lastArgument.getPossibleChildNames()) { org.opendaylight.yangtools.yang.data.api.InstanceIdentifier childPath = new org.opendaylight.yangtools.yang.data.api.InstanceIdentifier( - ImmutableList. builder().addAll(normalized.getPath()).add(new NodeIdentifier(child)) + ImmutableList. builder().addAll(normalized.getPathArguments()).add(new NodeIdentifier(child)) .build()); try { if (isNotRepresentable(childPath)) { @@ -218,19 +221,26 @@ public class BindingToNormalizedNodeCodec implements SchemaContextListener { final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier normalized) throws DataNormalizationException { DataNormalizationOperation current = legacyToNormalized.getRootOperation(); - for (PathArgument arg : normalized.getPath()) { + for (PathArgument arg : normalized.getPathArguments()) { current = current.getChild(arg); } return current; } - private static final Entry, DataObject> toEntry( + private static final Entry, DataObject> toBindingEntry( final org.opendaylight.yangtools.yang.binding.InstanceIdentifier key, final DataObject value) { return new SimpleEntry, DataObject>( key, value); } + private static final Entry> toDOMEntry( + final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier key, + final NormalizedNode value) { + return new SimpleEntry>( + key, value); + } + public DataObject toBinding(final InstanceIdentifier path, final NormalizedNode normalizedNode) throws DeserializationException { CompositeNode legacy = null; @@ -262,7 +272,7 @@ public class BindingToNormalizedNodeCodec implements SchemaContextListener { if (bindingData == null) { LOG.warn("Failed to deserialize {} to Binding format. Binding path is: {}", normalized, bindingPath); } - return Optional.of(toEntry(bindingPath, bindingData)); + return Optional.of(toBindingEntry(bindingPath, bindingData)); } else { return Optional.absent(); } @@ -304,15 +314,15 @@ public class BindingToNormalizedNodeCodec implements SchemaContextListener { final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier normalized) { int position = 0; int foundPosition = -1; - for (PathArgument arg : normalized.getPath()) { + for (PathArgument arg : normalized.getPathArguments()) { position++; if (arg instanceof AugmentationIdentifier) { foundPosition = position; } } if (foundPosition > 0) { - return new org.opendaylight.yangtools.yang.data.api.InstanceIdentifier(normalized.getPath().subList(0, - foundPosition)); + Iterable shortened = Iterables.limit(normalized.getPathArguments(), foundPosition); + return org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.create(shortened); } return null; } @@ -404,7 +414,7 @@ public class BindingToNormalizedNodeCodec implements SchemaContextListener { } private boolean isAugmentationIdentifier(final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier processed) { - return Iterables.getLast(processed.getPath()) instanceof AugmentationIdentifier; + return Iterables.getLast(processed.getPathArguments()) instanceof AugmentationIdentifier; } private static int getAugmentationCount(final InstanceIdentifier potential) { @@ -420,11 +430,46 @@ public class BindingToNormalizedNodeCodec implements SchemaContextListener { private static int getAugmentationCount(final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier potential) { int count = 0; - for(PathArgument arg : potential.getPath()) { + for(PathArgument arg : potential.getPathArguments()) { if(arg instanceof AugmentationIdentifier) { count++; } } return count; } + + public Function>, Optional> deserializeFunction(final InstanceIdentifier path) { + return new DeserializeFunction(this, path); + } + + private static class DeserializeFunction implements Function>, Optional> { + + private final BindingToNormalizedNodeCodec codec; + private final InstanceIdentifier path; + + public DeserializeFunction(final BindingToNormalizedNodeCodec codec, final InstanceIdentifier path) { + super(); + this.codec = Preconditions.checkNotNull(codec, "Codec must not be null"); + this.path = Preconditions.checkNotNull(path, "Path must not be null"); + } + + @Nullable + @Override + public Optional apply(@Nullable final Optional> normalizedNode) { + if (normalizedNode.isPresent()) { + final DataObject dataObject; + try { + dataObject = codec.toBinding(path, normalizedNode.get()); + } catch (DeserializationException e) { + LOG.warn("Failed to create dataobject from node {}", normalizedNode.get(), e); + throw new IllegalStateException("Failed to create dataobject", e); + } + + if (dataObject != null) { + return Optional.of(dataObject); + } + } + return Optional.absent(); + } + } } diff --git a/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/md/sal/binding/impl/ForwardedBackwardsCompatibleDataBroker.java b/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/md/sal/binding/impl/ForwardedBackwardsCompatibleDataBroker.java index 49d04d04b3..1c6447a4e7 100644 --- a/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/md/sal/binding/impl/ForwardedBackwardsCompatibleDataBroker.java +++ b/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/md/sal/binding/impl/ForwardedBackwardsCompatibleDataBroker.java @@ -186,7 +186,7 @@ public class ForwardedBackwardsCompatibleDataBroker extends AbstractForwardedDat } private class ForwardedBackwardsCompatibleTransacion extends - AbstractForwardedTransaction implements DataModificationTransaction { + AbstractReadWriteTransaction implements DataModificationTransaction { private final ListenerRegistry listeners = ListenerRegistry.create(); private final Map, DataObject> updated = new HashMap<>(); @@ -214,9 +214,9 @@ public class ForwardedBackwardsCompatibleDataBroker extends AbstractForwardedDat public void putOperationalData(final InstanceIdentifier path, final DataObject data) { boolean previouslyRemoved = posponedRemovedOperational.remove(path); if(previouslyRemoved) { - doPutWithEnsureParents(getDelegate(), LogicalDatastoreType.OPERATIONAL, path, data); + doPutWithEnsureParents(LogicalDatastoreType.OPERATIONAL, path, data); } else { - doMergeWithEnsureParents(getDelegate(), LogicalDatastoreType.OPERATIONAL, path, data); + doMergeWithEnsureParents(LogicalDatastoreType.OPERATIONAL, path, data); } } @@ -232,9 +232,9 @@ public class ForwardedBackwardsCompatibleDataBroker extends AbstractForwardedDat } updated.put(path, data); if(previouslyRemoved) { - doPutWithEnsureParents(getDelegate(), LogicalDatastoreType.CONFIGURATION, path, data); + doPutWithEnsureParents(LogicalDatastoreType.CONFIGURATION, path, data); } else { - doMergeWithEnsureParents(getDelegate(), LogicalDatastoreType.CONFIGURATION, path, data); + doMergeWithEnsureParents(LogicalDatastoreType.CONFIGURATION, path, data); } } @@ -308,11 +308,6 @@ public class ForwardedBackwardsCompatibleDataBroker extends AbstractForwardedDat } } - @Override - public Object getIdentifier() { - return getDelegate().getIdentifier(); - } - private void changeStatus(final TransactionStatus status) { LOG.trace("Transaction {} changed status to {}", getIdentifier(), status); this.status = status; @@ -330,11 +325,11 @@ public class ForwardedBackwardsCompatibleDataBroker extends AbstractForwardedDat public ListenableFuture> commit() { for(InstanceIdentifier path : posponedRemovedConfiguration) { - doDelete(getDelegate(), LogicalDatastoreType.CONFIGURATION, path); + doDelete(LogicalDatastoreType.CONFIGURATION, path); } for(InstanceIdentifier path : posponedRemovedOperational) { - doDelete(getDelegate(), LogicalDatastoreType.OPERATIONAL, path); + doDelete(LogicalDatastoreType.OPERATIONAL, path); } changeStatus(TransactionStatus.SUBMITED); diff --git a/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/md/sal/binding/impl/ForwardedBindingDataBroker.java b/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/md/sal/binding/impl/ForwardedBindingDataBroker.java index 5b008ad4bc..c8794cdc89 100644 --- a/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/md/sal/binding/impl/ForwardedBindingDataBroker.java +++ b/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/md/sal/binding/impl/ForwardedBindingDataBroker.java @@ -12,23 +12,10 @@ import org.opendaylight.controller.md.sal.binding.api.DataBroker; import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction; import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction; import org.opendaylight.controller.md.sal.binding.api.WriteTransaction; -import org.opendaylight.controller.md.sal.common.api.TransactionStatus; -import org.opendaylight.controller.md.sal.common.api.data.AsyncTransaction; -import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker; -import org.opendaylight.controller.md.sal.dom.api.DOMDataReadOnlyTransaction; -import org.opendaylight.controller.md.sal.dom.api.DOMDataReadWriteTransaction; -import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction; import org.opendaylight.controller.sal.core.api.model.SchemaService; -import org.opendaylight.yangtools.yang.binding.DataObject; -import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; -import org.opendaylight.yangtools.yang.common.RpcResult; -import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode; import org.opendaylight.yangtools.yang.data.impl.codec.BindingIndependentMappingService; -import com.google.common.base.Optional; -import com.google.common.util.concurrent.ListenableFuture; - /** * The DataBrokerImpl simply defers to the DOMDataBroker for all its operations. * All transactions and listener registrations are wrapped by the DataBrokerImpl @@ -37,9 +24,7 @@ import com.google.common.util.concurrent.ListenableFuture; * Besides this the DataBrokerImpl and it's collaborators also cache data that * is already transformed from the binding independent to binding aware format * - * TODO : All references in this class to CompositeNode should be switched to - * NormalizedNode once the MappingService is updated - * + */ public class ForwardedBindingDataBroker extends AbstractForwardedDataBroker implements DataBroker { @@ -60,90 +45,6 @@ public class ForwardedBindingDataBroker extends AbstractForwardedDataBroker impl @Override public WriteTransaction newWriteOnlyTransaction() { - return new BindingDataWriteTransactionImpl(getDelegate().newWriteOnlyTransaction(),getCodec()); - } - - private abstract class AbstractBindingTransaction>> - extends AbstractForwardedTransaction implements AsyncTransaction, DataObject> { - - protected AbstractBindingTransaction(final T delegate, final BindingToNormalizedNodeCodec codec) { - super(delegate, codec); - } - - @Override - public Object getIdentifier() { - return getDelegate().getIdentifier(); - } - - } - - - private class BindingDataReadTransactionImpl extends AbstractBindingTransaction implements - ReadOnlyTransaction { - - protected BindingDataReadTransactionImpl(final DOMDataReadOnlyTransaction delegate, - final BindingToNormalizedNodeCodec codec) { - super(delegate, codec); - } - - @Override - public ListenableFuture> read(final LogicalDatastoreType store, - final InstanceIdentifier path) { - return doRead(getDelegate(), store, path); - } - - @Override - public void close() { - getDelegate().close(); - } - } - - private class BindingDataWriteTransactionImpl extends - AbstractBindingTransaction implements WriteTransaction { - - protected BindingDataWriteTransactionImpl(final T delegate, final BindingToNormalizedNodeCodec codec) { - super(delegate, codec); - - } - - @Override - public boolean cancel() { - return doCancel(getDelegate()); - } - - @Override - public void put(final LogicalDatastoreType store, final InstanceIdentifier path, final DataObject data) { - doPut(getDelegate(), store, path, data); - } - - @Override - public void merge(final LogicalDatastoreType store, final InstanceIdentifier path, final DataObject data) { - doMerge(getDelegate(), store, path, data); - } - - @Override - public void delete(final LogicalDatastoreType store, final InstanceIdentifier path) { - doDelete(getDelegate(), store, path); - } - - @Override - public ListenableFuture> commit() { - return doCommit(getDelegate()); - } - } - - private class BindingDataReadWriteTransactionImpl extends - BindingDataWriteTransactionImpl implements ReadWriteTransaction { - - protected BindingDataReadWriteTransactionImpl(final DOMDataReadWriteTransaction delegate, - final BindingToNormalizedNodeCodec codec) { - super(delegate, codec); - } - - @Override - public ListenableFuture> read(final LogicalDatastoreType store, - final InstanceIdentifier path) { - return doRead(getDelegate(), store, path); - } + return new BindingDataWriteTransactionImpl<>(getDelegate().newWriteOnlyTransaction(),getCodec()); } } -- 2.36.6