final DOMDataReadOnlyTransaction beforeTx = new VppReadOnlyTransaction(EMPTY_OPERATIONAL, takeSnapshot());
final ConfigSnapshot modificationSnapshot = new ConfigSnapshot(modification);
final DOMDataReadOnlyTransaction afterTx = new VppReadOnlyTransaction(EMPTY_OPERATIONAL, modificationSnapshot);
- final WriteContext ctx = new TransactionWriteContext(serializer, beforeTx, afterTx);
-
- try {
+ try(final WriteContext ctx = new TransactionWriteContext(serializer, beforeTx, afterTx)) {
writer.update(nodesBefore, nodesAfter, ctx);
} catch (WriterRegistry.BulkUpdateException e) {
LOG.warn("Failed to apply all changes", e);
import com.google.common.util.concurrent.CheckedFuture;
import com.google.common.util.concurrent.Futures;
import io.fd.honeycomb.v3po.impl.trans.ReadFailedException;
+import io.fd.honeycomb.v3po.impl.trans.r.ReadContext;
import io.fd.honeycomb.v3po.impl.trans.r.ReaderRegistry;
+import io.fd.honeycomb.v3po.impl.trans.util.Context;
import java.util.Collection;
import java.util.Map;
import javax.annotation.Nonnull;
org.opendaylight.controller.md.sal.common.api.data.ReadFailedException> read(
@Nonnull final YangInstanceIdentifier yangInstanceIdentifier) {
- try {
+ try(ReadContext ctx = new ReadContextImpl()) {
if (checkNotNull(yangInstanceIdentifier).equals(YangInstanceIdentifier.EMPTY)) {
- return Futures.immediateCheckedFuture(readRoot());
+ return Futures.immediateCheckedFuture(readRoot(ctx));
} else {
- return Futures.immediateCheckedFuture(readNode(yangInstanceIdentifier));
+ return Futures.immediateCheckedFuture(readNode(yangInstanceIdentifier, ctx));
}
} catch (ReadFailedException e) {
return Futures.immediateFailedCheckedFuture(
}
}
- private Optional<NormalizedNode<?, ?>> readNode(final YangInstanceIdentifier yangInstanceIdentifier)
+ private Optional<NormalizedNode<?, ?>> readNode(final YangInstanceIdentifier yangInstanceIdentifier,
+ final ReadContext ctx)
throws ReadFailedException {
LOG.debug("VppOperationalDataTree.readNode(), yangInstanceIdentifier={}", yangInstanceIdentifier);
final InstanceIdentifier<?> path = serializer.fromYangInstanceIdentifier(yangInstanceIdentifier);
final Optional<? extends DataObject> dataObject;
- dataObject = readerRegistry.read(path);
+ dataObject = readerRegistry.read(path, ctx);
if (dataObject.isPresent()) {
final NormalizedNode<?, ?> value = toNormalizedNodeFunction(path).apply(dataObject.get());
return Optional.<NormalizedNode<?, ?>>fromNullable(value);
}
}
- private Optional<NormalizedNode<?, ?>> readRoot() throws ReadFailedException {
+ private Optional<NormalizedNode<?, ?>> readRoot(final ReadContext ctx) throws ReadFailedException {
LOG.debug("VppOperationalDataTree.readRoot()");
final DataContainerNodeAttrBuilder<YangInstanceIdentifier.NodeIdentifier, ContainerNode> dataNodeBuilder =
.withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(SchemaContext.NAME));
final Multimap<InstanceIdentifier<? extends DataObject>, ? extends DataObject> dataObjects =
- readerRegistry.readAll();
+ readerRegistry.readAll(ctx);
for (final InstanceIdentifier<? extends DataObject> instanceIdentifier : dataObjects.keySet()) {
final YangInstanceIdentifier rootElementId = serializer.toYangInstanceIdentifier(instanceIdentifier);
}
};
}
+
+ private static final class ReadContextImpl implements ReadContext {
+ public final Context ctx = new Context();
+
+ @Nonnull
+ @Override
+ public Context getContext() {
+ return ctx;
+ }
+
+ @Override
+ public void close() {
+ // Make sure to clear the storage in case some customizer stored it to prevent memory leaks
+ ctx.close();
+ }
+ }
}
import com.google.common.collect.Multimap;
import io.fd.honeycomb.v3po.impl.trans.ReadFailedException;
import io.fd.honeycomb.v3po.impl.trans.r.ChildVppReader;
+import io.fd.honeycomb.v3po.impl.trans.r.ReadContext;
import io.fd.honeycomb.v3po.impl.trans.r.ReaderRegistry;
import io.fd.honeycomb.v3po.impl.trans.r.VppReader;
import io.fd.honeycomb.v3po.impl.trans.r.impl.CompositeChildVppReader;
@Nonnull
@Override
- public Multimap<InstanceIdentifier<? extends DataObject>, ? extends DataObject> readAll()
- throws io.fd.honeycomb.v3po.impl.trans.ReadFailedException {
- return reader.readAll();
+ public Multimap<InstanceIdentifier<? extends DataObject>, ? extends DataObject> readAll(
+ @Nonnull final ReadContext ctx) throws io.fd.honeycomb.v3po.impl.trans.ReadFailedException {
+ return reader.readAll(ctx);
}
@Nonnull
@Override
- public Optional<? extends DataObject> read(@Nonnull final InstanceIdentifier<? extends DataObject> id)
- throws ReadFailedException {
- return reader.read(id);
+ public Optional<? extends DataObject> read(@Nonnull final InstanceIdentifier<? extends DataObject> id,
+ @Nonnull final ReadContext ctx) throws ReadFailedException {
+ return reader.read(id, ctx);
}
@Nonnull
* determine the exact position within more complex subtrees.
* @param parentBuilder Builder of parent DataObject. Objects read on this level (if any) must be placed into the
* parent builder.
+ * @param ctx Read context
+ *
* @throws ReadFailedException if read was unsuccessful
*/
void read(@Nonnull final InstanceIdentifier<? extends DataObject> id,
- @Nonnull final Builder<? extends DataObject> parentBuilder) throws ReadFailedException;
+ @Nonnull final Builder<? extends DataObject> parentBuilder,
+ @Nonnull final ReadContext ctx) throws ReadFailedException;
}
* Read all elements in this list
*
* @param id Wildcarded identifier of list managed by this reader
+ * @param ctx Read context
*
* @return List of all entries in this list
* @throws ReadFailedException if read was unsuccessful
*/
@Nonnull
- List<D> readList(@Nonnull final InstanceIdentifier<D> id) throws ReadFailedException;
+ List<D> readList(@Nonnull final InstanceIdentifier<D> id,
+ @Nonnull final ReadContext ctx) throws ReadFailedException;
}
--- /dev/null
+/*
+ * Copyright (c) 2016 Cisco and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.fd.honeycomb.v3po.impl.trans.r;
+
+import io.fd.honeycomb.v3po.impl.trans.util.Context;
+import javax.annotation.Nonnull;
+
+/**
+ * Read Context
+ */
+public interface ReadContext extends AutoCloseable {
+
+ /**
+ * Get key value storage for customizers
+ *
+ * @return Context for customizers
+ */
+ @Nonnull
+ Context getContext();
+
+ @Override
+ void close();
+}
* Performs read on all registered root readers and merges the results into a Multimap. Keys represent identifiers
* for root DataObjects from the data tree modeled by YANG.
*
+ * @param ctx Read context
+ *
* @return multimap that preserves deterministic iteration order across non-distinct key values
* @throws ReadFailedException if read was unsuccessful
*/
@Nonnull
- Multimap<InstanceIdentifier<? extends DataObject>, ? extends DataObject> readAll()
+ Multimap<InstanceIdentifier<? extends DataObject>, ? extends DataObject> readAll(@Nonnull final ReadContext ctx)
throws ReadFailedException;
}
@Beta
public interface VppReader<D extends DataObject> extends SubtreeManager<D> {
- // TODO add vpp read context that will be shared by all readers during a single read to keep useful information
- // preventing possible duplicate reads from VPP
// TODO make async
/**
* @param id unique identifier of subtree to be read. The subtree must contain managed data object type. For
* identifiers pointing below node managed by this reader, it's reader's responsibility to filter out the
* right node or to delegate the read to a child reader.
+ * @param ctx Read context
+ *
* @return List of DataObjects identified by id. If the ID points to a single node, it will be wrapped in a list
* @throws ReadFailedException if read was unsuccessful
*/
@Nonnull
- Optional<? extends DataObject> read(@Nonnull final InstanceIdentifier<? extends DataObject> id) throws
- ReadFailedException;
+ Optional<? extends DataObject> read(@Nonnull final InstanceIdentifier<? extends DataObject> id,
+ @Nonnull ReadContext ctx) throws ReadFailedException;
}
import com.google.common.collect.Iterables;
import io.fd.honeycomb.v3po.impl.trans.ReadFailedException;
import io.fd.honeycomb.v3po.impl.trans.r.ChildVppReader;
+import io.fd.honeycomb.v3po.impl.trans.r.ReadContext;
import io.fd.honeycomb.v3po.impl.trans.r.VppReader;
import io.fd.honeycomb.v3po.impl.trans.util.ReflectionUtils;
import io.fd.honeycomb.v3po.impl.trans.util.VppRWUtils;
/**
* @param id {@link InstanceIdentifier} pointing to current node. In case of keyed list, key must be present.
+ *
*/
- protected Optional<D> readCurrent(final InstanceIdentifier<D> id) throws
+ protected Optional<D> readCurrent(final InstanceIdentifier<D> id,
+ @Nonnull final ReadContext ctx) throws
ReadFailedException {
LOG.debug("{}: Reading current: {}", this, id);
final B builder = getBuilder(id);
final D emptyValue = builder.build();
LOG.trace("{}: Reading current attributes", this);
- readCurrentAttributes(id, builder);
+ readCurrentAttributes(id, builder, ctx);
// TODO expect exceptions from reader
for (ChildVppReader<? extends ChildOf<D>> child : childReaders.values()) {
LOG.debug("{}: Reading child from: {}", this, child);
- child.read(id, builder);
+ child.read(id, builder, ctx);
}
for (ChildVppReader<? extends Augmentation<D>> child : augReaders.values()) {
LOG.debug("{}: Reading augment from: {}", this, child);
- child.read(id, builder);
+ child.read(id, builder, ctx);
}
// Need to check whether anything was filled in to determine if data is present or not.
@Nonnull
@Override
@SuppressWarnings("unchecked")
- public Optional<? extends DataObject> read(@Nonnull final InstanceIdentifier<? extends DataObject> id)
+ public Optional<? extends DataObject> read(@Nonnull final InstanceIdentifier<? extends DataObject> id,
+ @Nonnull final ReadContext ctx)
throws ReadFailedException {
LOG.trace("{}: Reading : {}", this, id);
if (id.getTargetType().equals(getManagedDataObjectType().getTargetType())) {
- return readCurrent((InstanceIdentifier<D>) id);
+ return readCurrent((InstanceIdentifier<D>) id, ctx);
} else {
- return readSubtree(id);
+ return readSubtree(id, ctx);
}
}
- private Optional<? extends DataObject> readSubtree(final InstanceIdentifier<? extends DataObject> id)
+ private Optional<? extends DataObject> readSubtree(final InstanceIdentifier<? extends DataObject> id,
+ @Nonnull final ReadContext ctx)
throws ReadFailedException {
LOG.debug("{}: Reading subtree: {}", this, id);
final Class<? extends DataObject> next = VppRWUtils.getNextId(id, getManagedDataObjectType()).getType();
if (vppReader != null) {
LOG.debug("{}: Reading subtree: {} from: {}", this, id, vppReader);
- return vppReader.read(id);
+ return vppReader.read(id, ctx);
} else {
LOG.debug("{}: Dedicated subtree reader missing for: {}. Reading current and filtering", this, next);
// If there's no dedicated reader, use read current
final InstanceIdentifier<D> currentId = VppRWUtils.cutId(id, getManagedDataObjectType());
- final Optional<D> current = readCurrent(currentId);
+ final Optional<D> current = readCurrent(currentId, ctx);
// then perform post-reading filtering (return only requested sub-node)
final Optional<? extends DataObject> readSubtree = current.isPresent()
? filterSubtree(current.get(), id, getManagedDataObjectType().getTargetType())
*
* @param id {@link InstanceIdentifier} pointing to current node. In case of keyed list, key must be present.
* @param builder Builder object for current node where the read attributes must be placed
+ * @param ctx Current read context
*/
- protected abstract void readCurrentAttributes(final InstanceIdentifier<D> id, B builder) throws
- ReadFailedException;
+ protected abstract void readCurrentAttributes(@Nonnull final InstanceIdentifier<D> id, @Nonnull final B builder,
+ @Nonnull final ReadContext ctx) throws ReadFailedException;
/**
* Return new instance of a builder object for current node
import com.google.common.base.Optional;
import io.fd.honeycomb.v3po.impl.trans.ReadFailedException;
import io.fd.honeycomb.v3po.impl.trans.r.ChildVppReader;
+import io.fd.honeycomb.v3po.impl.trans.r.ReadContext;
import io.fd.honeycomb.v3po.impl.trans.r.impl.spi.ChildVppReaderCustomizer;
import io.fd.honeycomb.v3po.impl.trans.util.VppRWUtils;
import java.util.List;
@Override
public final void read(@Nonnull final InstanceIdentifier<? extends DataObject> parentId,
- @Nonnull final Builder<? extends DataObject> parentBuilder) throws ReadFailedException {
- final Optional<C> read = readCurrent(VppRWUtils.appendTypeToId(parentId, getManagedDataObjectType()));
+ @Nonnull final Builder<? extends DataObject> parentBuilder,
+ @Nonnull final ReadContext ctx) throws ReadFailedException {
+ final Optional<C> read = readCurrent(VppRWUtils.appendTypeToId(parentId, getManagedDataObjectType()), ctx);
if(read.isPresent()) {
customizer.merge(parentBuilder, read.get());
}
@Override
- protected void readCurrentAttributes(@Nonnull final InstanceIdentifier<C> id, @Nonnull final B builder)
+ protected void readCurrentAttributes(@Nonnull final InstanceIdentifier<C> id, @Nonnull final B builder,
+ @Nonnull final ReadContext ctx)
throws ReadFailedException {
- customizer.readCurrentAttributes(id, builder);
+ customizer.readCurrentAttributes(id, builder, ctx.getContext());
}
@Override
import io.fd.honeycomb.v3po.impl.trans.ReadFailedException;
import io.fd.honeycomb.v3po.impl.trans.r.ChildVppReader;
import io.fd.honeycomb.v3po.impl.trans.r.ListVppReader;
+import io.fd.honeycomb.v3po.impl.trans.r.ReadContext;
import io.fd.honeycomb.v3po.impl.trans.r.impl.spi.ListVppReaderCustomizer;
import io.fd.honeycomb.v3po.impl.trans.util.VppRWUtils;
import java.util.ArrayList;
@Override
public void read(@Nonnull final InstanceIdentifier<? extends DataObject> id,
- @Nonnull final Builder<? extends DataObject> parentBuilder) throws ReadFailedException {
+ @Nonnull final Builder<? extends DataObject> parentBuilder,
+ @Nonnull final ReadContext ctx) throws ReadFailedException {
// Create ID pointing to current node
final InstanceIdentifier<C> currentId = VppRWUtils.appendTypeToId(id, getManagedDataObjectType());
// Read all, since current ID is definitely wildcarded
- final List<C> ifcs = readList(currentId);
+ final List<C> ifcs = readList(currentId, ctx);
customizer.merge(parentBuilder, ifcs);
}
@Override
@Nonnull
- public List<C> readList(@Nonnull final InstanceIdentifier<C> id) throws ReadFailedException {
+ public List<C> readList(@Nonnull final InstanceIdentifier<C> id,
+ @Nonnull final ReadContext ctx) throws ReadFailedException {
LOG.trace("{}: Reading all list entries", this);
- final List<K> allIds = customizer.getAllIds(id);
+ final List<K> allIds = customizer.getAllIds(id, ctx.getContext());
LOG.debug("{}: Reading list entries for: {}", this, allIds);
final ArrayList<C> allEntries = new ArrayList<>(allIds.size());
final InstanceIdentifier.IdentifiableItem<C, K> currentBdItem =
VppRWUtils.getCurrentIdItem(id, key);
final InstanceIdentifier<C> keyedId = VppRWUtils.replaceLastInId(id, currentBdItem);
- final Optional<C> read = readCurrent(keyedId);
+ final Optional<C> read = readCurrent(keyedId, ctx);
final DataObject singleItem = read.get();
checkArgument(getManagedDataObjectType().getTargetType().isAssignableFrom(singleItem.getClass()));
allEntries.add(getManagedDataObjectType().getTargetType().cast(singleItem));
}
@Override
- protected void readCurrentAttributes(@Nonnull final InstanceIdentifier<C> id, @Nonnull final B builder)
+ protected void readCurrentAttributes(@Nonnull final InstanceIdentifier<C> id, @Nonnull final B builder,
+ @Nonnull final ReadContext ctx)
throws ReadFailedException {
- customizer.readCurrentAttributes(id, builder);
+ customizer.readCurrentAttributes(id, builder, ctx.getContext());
}
@Override
import com.google.common.annotations.Beta;
import io.fd.honeycomb.v3po.impl.trans.ReadFailedException;
import io.fd.honeycomb.v3po.impl.trans.r.ChildVppReader;
+import io.fd.honeycomb.v3po.impl.trans.r.ReadContext;
import io.fd.honeycomb.v3po.impl.trans.r.VppReader;
import io.fd.honeycomb.v3po.impl.trans.r.impl.spi.RootVppReaderCustomizer;
import io.fd.honeycomb.v3po.impl.trans.util.VppRWUtils;
}
@Override
- protected void readCurrentAttributes(@Nonnull final InstanceIdentifier<C> id, @Nonnull final B builder)
+ protected void readCurrentAttributes(@Nonnull final InstanceIdentifier<C> id, @Nonnull final B builder,
+ @Nonnull final ReadContext ctx)
throws ReadFailedException {
- customizer.readCurrentAttributes(id, builder);
+ customizer.readCurrentAttributes(id, builder, ctx.getContext());
}
@Override
package io.fd.honeycomb.v3po.impl.trans.r.impl.spi;
import com.google.common.annotations.Beta;
+import io.fd.honeycomb.v3po.impl.trans.util.Context;
import java.util.List;
import javax.annotation.Nonnull;
import org.opendaylight.yangtools.concepts.Builder;
/**
* Return list with IDs of all list nodes to be read.
*
- * @param id wildcarded ID pointing to list node managed by enclosing reader
+ * @param id Wildcarded ID pointing to list node managed by enclosing reader
+ * @param context Read context
*/
@Nonnull
- List<K> getAllIds(@Nonnull final InstanceIdentifier<C> id);
+ List<K> getAllIds(@Nonnull final InstanceIdentifier<C> id, @Nonnull final Context context);
// TODO does it make sense with vpp APIs ? Should we replace it with a simple readAll ?
/**
import com.google.common.annotations.Beta;
import io.fd.honeycomb.v3po.impl.trans.ReadFailedException;
+import io.fd.honeycomb.v3po.impl.trans.util.Context;
import javax.annotation.Nonnull;
import org.opendaylight.yangtools.concepts.Builder;
import org.opendaylight.yangtools.yang.binding.DataObject;
* @param builder builder for creating read value
* @throws ReadFailedException if read was unsuccessful
*/
- void readCurrentAttributes(@Nonnull final InstanceIdentifier<C> id, @Nonnull final B builder) throws
- ReadFailedException;
+ void readCurrentAttributes(@Nonnull final InstanceIdentifier<C> id, @Nonnull final B builder,
+ @Nonnull final Context ctx) throws ReadFailedException;
}
import com.google.common.collect.Multimap;
import io.fd.honeycomb.v3po.impl.trans.ReadFailedException;
import io.fd.honeycomb.v3po.impl.trans.r.ListVppReader;
+import io.fd.honeycomb.v3po.impl.trans.r.ReadContext;
import io.fd.honeycomb.v3po.impl.trans.r.ReaderRegistry;
import io.fd.honeycomb.v3po.impl.trans.r.VppReader;
import io.fd.honeycomb.v3po.impl.trans.util.VppRWUtils;
@Override
@Nonnull
- public Multimap<InstanceIdentifier<? extends DataObject>, ? extends DataObject> readAll()
- throws ReadFailedException {
+ public Multimap<InstanceIdentifier<? extends DataObject>, ? extends DataObject> readAll(
+ @Nonnull final ReadContext ctx) throws ReadFailedException {
+
LOG.debug("Reading from all delegates: {}", this);
LOG.trace("Reading from all delegates: {}", rootReaders.values());
if (rootReader instanceof ListVppReader) {
final List<? extends DataObject> listEntries =
- ((ListVppReader) rootReader).readList(rootReader.getManagedDataObjectType());
+ ((ListVppReader) rootReader).readList(rootReader.getManagedDataObjectType(), ctx);
if (!listEntries.isEmpty()) {
objects.putAll(rootReader.getManagedDataObjectType(), listEntries);
}
} else {
- final Optional<? extends DataObject> read = rootReader.read(rootReader.getManagedDataObjectType());
+ final Optional<? extends DataObject> read = rootReader.read(rootReader.getManagedDataObjectType(), ctx);
if (read.isPresent()) {
objects.putAll(rootReader.getManagedDataObjectType(), Collections.singletonList(read.get()));
}
@Nonnull
@Override
- public Optional<? extends DataObject> read(@Nonnull final InstanceIdentifier<? extends DataObject> id)
+ public Optional<? extends DataObject> read(@Nonnull final InstanceIdentifier<? extends DataObject> id,
+ @Nonnull final ReadContext ctx)
throws ReadFailedException {
final InstanceIdentifier.PathArgument first = checkNotNull(
Iterables.getFirst(id.getPathArguments(), null), "Empty id");
checkNotNull(vppReader,
"Unable to read %s. Missing reader. Current readers for: %s", id, rootReaders.keySet());
LOG.debug("Reading from delegate: {}", vppReader);
- return vppReader.read(id);
+ return vppReader.read(id, ctx);
}
/**
package io.fd.honeycomb.v3po.impl.trans.r.util;
import io.fd.honeycomb.v3po.impl.trans.r.impl.spi.RootVppReaderCustomizer;
+import io.fd.honeycomb.v3po.impl.trans.util.Context;
import org.opendaylight.yangtools.concepts.Builder;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
public abstract class NoopReaderCustomizer<C extends DataObject, B extends Builder<C>> implements RootVppReaderCustomizer<C, B> {
@Override
- public void readCurrentAttributes(InstanceIdentifier<C> id, final B builder) {
+ public void readCurrentAttributes(InstanceIdentifier<C> id, final B builder, final Context context) {
// Noop
}
}
/**
* Simple context class that provides transient storage during one or more read/write operations
*/
-public class Context {
+public class Context implements AutoCloseable {
protected final HashMap<Object, Object> map;
return map.put(o, o2);
}
- public void close() throws Exception {
+ @Override
+ public void close() {
map.clear();
}
}
* Context providing information about current state of DataTree to writers
*/
@Beta
-public interface WriteContext {
+public interface WriteContext extends AutoCloseable {
/**
* Read any data object before current modification was applied
*/
@Nonnull
Context getContext();
+
+ @Override
+ void close();
}
/**
* Transaction based WriteContext
*/
-public final class TransactionWriteContext implements WriteContext, AutoCloseable {
+public final class TransactionWriteContext implements WriteContext {
private final DOMDataReadOnlyTransaction beforeTx;
private final DOMDataReadOnlyTransaction afterTx;
* Does not close the transactions
*/
@Override
- public void close() throws Exception {
+ public void close() {
ctx.close();
}
}
import com.google.common.collect.Lists;
import io.fd.honeycomb.v3po.impl.trans.r.impl.spi.ListVppReaderCustomizer;
+import io.fd.honeycomb.v3po.impl.trans.util.Context;
import io.fd.honeycomb.v3po.impl.trans.util.VppApiCustomizer;
import java.util.ArrayList;
import java.util.List;
@Override
public void readCurrentAttributes(@Nonnull final InstanceIdentifier<BridgeDomain> id,
- @Nonnull final BridgeDomainBuilder builder) {
+ @Nonnull final BridgeDomainBuilder builder, @Nonnull final Context context) {
final BridgeDomainKey key = id.firstKeyOf(id.getTargetType());
// TODO find out if bd exists based on name and if not return
@Nonnull
@Override
- public List<BridgeDomainKey> getAllIds(@Nonnull final InstanceIdentifier<BridgeDomain> id) {
+ public List<BridgeDomainKey> getAllIds(@Nonnull final InstanceIdentifier<BridgeDomain> id, @Nonnull final Context context) {
final int[] bIds = getVppApi().bridgeDomainDump(-1);
final List<BridgeDomainKey> allIds = new ArrayList<>(bIds.length);
for (int bId : bIds) {
// FIXME this is highly inefficient having to dump all of the bridge domain details
+ // Use context to store already read information
+ // TODO Or just remove the getAllIds method and replace with a simple readAll
final vppBridgeDomainDetails bridgeDomainDetails = getVppApi().getBridgeDomainDetails(bId);
final String bName = bridgeDomainDetails.name;
allIds.add(new BridgeDomainKey(bName));
package io.fd.honeycomb.v3po.impl.vppstate;
import io.fd.honeycomb.v3po.impl.trans.r.impl.spi.ChildVppReaderCustomizer;
+import io.fd.honeycomb.v3po.impl.trans.util.Context;
import io.fd.honeycomb.v3po.impl.trans.util.VppApiCustomizer;
import javax.annotation.Nonnull;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.VppStateBuilder;
}
@Override
- public void readCurrentAttributes(@Nonnull InstanceIdentifier<Version> id, @Nonnull final VersionBuilder builder) {
+ public void readCurrentAttributes(@Nonnull InstanceIdentifier<Version> id, @Nonnull final VersionBuilder builder,
+ @Nonnull final Context context) {
final vppVersion vppVersion = getVppApi().getVppVersion();
builder.setBranch(vppVersion.gitBranch);
builder.setName(vppVersion.programName);
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.same;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.doThrow;
import static org.mockito.Mockito.mock;
import com.google.common.collect.LinkedListMultimap;
import com.google.common.collect.Multimap;
import com.google.common.util.concurrent.CheckedFuture;
+import io.fd.honeycomb.v3po.impl.trans.r.ReadContext;
import io.fd.honeycomb.v3po.impl.trans.r.ReaderRegistry;
import java.util.Map;
import org.junit.Before;
private SchemaContext globalContext;
@Mock
private DataSchemaNode schemaNode;
+ @Mock
+ private ReadContext readCtx;
@Before
public void setUp() {
doReturn(id).when(serializer).fromYangInstanceIdentifier(yangId);
final DataObject dataObject = mock(DataObject.class);
- doReturn(Optional.of(dataObject)).when(reader).read(id);
+ doReturn(Optional.of(dataObject)).when(reader).read(same(id), any(ReadContext.class));
when(serializer.toNormalizedNode(id, dataObject)).thenReturn(entry);
final DataContainerChild<?, ?> expectedValue = mock(DataContainerChild.class);
final CheckedFuture<Optional<NormalizedNode<?, ?>>, ReadFailedException> future = operationalData.read(yangId);
verify(serializer).fromYangInstanceIdentifier(yangId);
- verify(reader).read(id);
+ verify(reader).read(same(id), any(ReadContext.class));
final Optional<NormalizedNode<?, ?>> result = future.get();
assertTrue(result.isPresent());
assertEquals(expectedValue, result.get());
public void testReadNonExistingNode() throws Exception {
final YangInstanceIdentifier yangId = mock(YangInstanceIdentifier.class);
doReturn(id).when(serializer).fromYangInstanceIdentifier(yangId);
- doReturn(Optional.absent()).when(reader).read(id);
+ doReturn(Optional.absent()).when(reader).read(same(id), any(ReadContext.class));
final CheckedFuture<Optional<NormalizedNode<?, ?>>, ReadFailedException> future = operationalData.read(yangId);
verify(serializer).fromYangInstanceIdentifier(yangId);
- verify(reader).read(id);
+ verify(reader).read(same(id), any(ReadContext.class));
final Optional<NormalizedNode<?, ?>> result = future.get();
assertFalse(result.isPresent());
}
@Test
public void testReadFailed() throws Exception{
- doThrow(io.fd.honeycomb.v3po.impl.trans.ReadFailedException.class).when(reader).readAll();
+ doThrow(io.fd.honeycomb.v3po.impl.trans.ReadFailedException.class).when(reader).readAll(any(ReadContext.class));
final CheckedFuture<Optional<NormalizedNode<?, ?>>, ReadFailedException> future =
operationalData.read( YangInstanceIdentifier.EMPTY);
final VppState vppState = mock(VppState.class);
Multimap<InstanceIdentifier<?>, DataObject> dataObjects = LinkedListMultimap.create();
dataObjects.put(vppStateII, vppState);
- doReturn(dataObjects).when(reader).readAll();
+ doReturn(dataObjects).when(reader).readAll(any(ReadContext.class));
// Init serializer
final YangInstanceIdentifier vppYangId = YangInstanceIdentifier.builder().node(VppState.QNAME).build();
final CheckedFuture<Optional<NormalizedNode<?, ?>>, ReadFailedException> future =
operationalData.read(YangInstanceIdentifier.EMPTY);
- verify(reader).readAll();
+ verify(reader).readAll(any(ReadContext.class));
verify(serializer).toYangInstanceIdentifier(vppStateII);
verify(serializer).toNormalizedNode(vppStateII, vppState);
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.mockito.Matchers.anyString;
+import static org.mockito.Mockito.mock;
import com.google.common.base.Optional;
import com.google.common.base.Predicate;
import com.google.common.collect.Iterables;
import com.google.common.collect.Multimap;
+import io.fd.honeycomb.v3po.impl.trans.r.ReadContext;
import io.fd.honeycomb.v3po.impl.trans.r.VppReader;
import io.fd.honeycomb.v3po.impl.trans.r.impl.CompositeListVppReader;
import io.fd.honeycomb.v3po.impl.trans.r.impl.CompositeRootVppReader;
private DelegatingReaderRegistry readerRegistry;
private vppBridgeDomainDetails bdDetails;
private vppBridgeDomainDetails bdDetails2;
+ private ReadContext ctx;
@Before
public void setUp() throws Exception {
api = PowerMockito.mock(vppApi.class);
+ ctx = mock(ReadContext.class);
+
bdDetails = new vppBridgeDomainDetails();
setIfcs(bdDetails);
setBaseAttrs(bdDetails, "bdn1", 1);
@Test
public void testReadAll() throws Exception {
- final Multimap<InstanceIdentifier<? extends DataObject>, ? extends DataObject> dataObjects = readerRegistry.readAll();
+ final Multimap<InstanceIdentifier<? extends DataObject>, ? extends DataObject> dataObjects = readerRegistry.readAll(ctx);
assertEquals(dataObjects.size(), 1);
final DataObject dataObject = Iterables.getOnlyElement(dataObjects.get(Iterables.getOnlyElement(dataObjects.keySet())));
assertTrue(dataObject instanceof VppState);
@Test
public void testReadSpecific() throws Exception {
- final Optional<? extends DataObject> read = readerRegistry.read(InstanceIdentifier.create(VppState.class));
+ final Optional<? extends DataObject> read = readerRegistry.read(InstanceIdentifier.create(VppState.class), ctx);
assertTrue(read.isPresent());
assertVersion((VppState) read.get());
}
@Test
public void testReadBridgeDomains() throws Exception {
- VppState readRoot = (VppState) readerRegistry.read(InstanceIdentifier.create(VppState.class)).get();
+ VppState readRoot = (VppState) readerRegistry.read(InstanceIdentifier.create(VppState.class), ctx).get();
Optional<? extends DataObject> read =
- readerRegistry.read(InstanceIdentifier.create(VppState.class).child(BridgeDomains.class));
+ readerRegistry.read(InstanceIdentifier.create(VppState.class).child(BridgeDomains.class), ctx);
assertTrue(read.isPresent());
assertEquals(readRoot.getBridgeDomains(), read.get());
}
Optional<? extends DataObject> read =
readerRegistry.read(InstanceIdentifier.create(VppState.class).child(BridgeDomains.class).child(
BridgeDomain.class, new BridgeDomainKey("bdn1"))
- .child(L2Fib.class, new L2FibKey(new PhysAddress("01:02:03:04:05:06"))));
+ .child(L2Fib.class, new L2FibKey(new PhysAddress("01:02:03:04:05:06"))), ctx);
assertTrue(read.isPresent());
// non existing l2fib
read =
readerRegistry.read(InstanceIdentifier.create(VppState.class).child(BridgeDomains.class).child(
BridgeDomain.class, new BridgeDomainKey("bdn1"))
- .child(L2Fib.class, new L2FibKey(new PhysAddress("FF:FF:FF:04:05:06"))));
+ .child(L2Fib.class, new L2FibKey(new PhysAddress("FF:FF:FF:04:05:06"))), ctx);
assertFalse(read.isPresent());
}
@Test
public void testReadBridgeDomainAll() throws Exception {
- VppState readRoot = (VppState) readerRegistry.read(InstanceIdentifier.create(VppState.class)).get();
+ VppState readRoot = (VppState) readerRegistry.read(InstanceIdentifier.create(VppState.class), ctx).get();
final CompositeListVppReader<BridgeDomain, BridgeDomainKey, BridgeDomainBuilder> bridgeDomainReader =
VppStateUtils.getBridgeDomainReader(api);
final List<BridgeDomain> read =
bridgeDomainReader.readList(InstanceIdentifier.create(VppState.class).child(BridgeDomains.class).child(
- BridgeDomain.class));
+ BridgeDomain.class), ctx);
assertEquals(readRoot.getBridgeDomains().getBridgeDomain(), read);
}
@Test
public void testReadBridgeDomain() throws Exception {
- VppState readRoot = (VppState) readerRegistry.read(InstanceIdentifier.create(VppState.class)).get();
+ VppState readRoot = (VppState) readerRegistry.read(InstanceIdentifier.create(VppState.class), ctx).get();
final Optional<? extends DataObject> read =
readerRegistry.read(InstanceIdentifier.create(VppState.class).child(BridgeDomains.class).child(
- BridgeDomain.class, new BridgeDomainKey("bdn1")));
+ BridgeDomain.class, new BridgeDomainKey("bdn1")), ctx);
assertTrue(read.isPresent());
assertEquals(Iterables.find(readRoot.getBridgeDomains().getBridgeDomain(), new Predicate<BridgeDomain>() {
public void testReadBridgeDomainNotExisting() throws Exception {
final Optional<? extends DataObject> read =
readerRegistry.read(InstanceIdentifier.create(VppState.class).child(BridgeDomains.class).child(
- BridgeDomain.class, new BridgeDomainKey("NOT EXISTING")));
+ BridgeDomain.class, new BridgeDomainKey("NOT EXISTING")), ctx);
assertFalse(read.isPresent());
}
@Test
public void testReadVersion() throws Exception {
- VppState readRoot = (VppState) readerRegistry.read(InstanceIdentifier.create(VppState.class)).get();
+ VppState readRoot = (VppState) readerRegistry.read(InstanceIdentifier.create(VppState.class), ctx).get();
Optional<? extends DataObject> read =
- readerRegistry.read(InstanceIdentifier.create(VppState.class).child(Version.class));
+ readerRegistry.read(InstanceIdentifier.create(VppState.class).child(Version.class), ctx);
assertTrue(read.isPresent());
assertEquals(readRoot.getVersion(), read.get());
}
Code Review / hc2vpp.git / commitdiff