summaryrefslogtreecommitdiffstats
path: root/infra/translate-utils/src
diff options
context:
space:
mode:
Diffstat (limited to 'infra/translate-utils/src')
-rw-r--r--infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/AbstractGenericReader.java9
-rw-r--r--infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/BindingBrokerReader.java5
-rw-r--r--infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/DelegatingReader.java103
-rw-r--r--infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/KeepaliveReaderWrapper.java40
-rw-r--r--infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/ReflexiveReader.java57
-rw-r--r--infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/ReflexiveReaderCustomizer.java2
-rw-r--r--infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/registry/CompositeReader.java241
-rw-r--r--infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/registry/CompositeReaderRegistry.java131
-rw-r--r--infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/registry/CompositeReaderRegistryBuilder.java114
-rw-r--r--infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/registry/InitSubtreeReader.java72
-rw-r--r--infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/registry/SubtreeReader.java241
-rw-r--r--infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/registry/TypeHierarchy.java101
-rw-r--r--infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/write/registry/FlatWriterRegistry.java314
-rw-r--r--infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/write/registry/FlatWriterRegistryBuilder.java71
-rw-r--r--infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/write/registry/SubtreeWriter.java85
-rw-r--r--infra/translate-utils/src/test/java/io/fd/honeycomb/translate/util/read/registry/CompositeReaderRegistryBuilderTest.java114
-rw-r--r--infra/translate-utils/src/test/java/io/fd/honeycomb/translate/util/read/registry/CompositeReaderRegistryTest.java112
-rw-r--r--infra/translate-utils/src/test/java/io/fd/honeycomb/translate/util/read/registry/CompositeReaderTest.java124
-rw-r--r--infra/translate-utils/src/test/java/io/fd/honeycomb/translate/util/read/registry/SubtreeReaderTest.java124
-rw-r--r--infra/translate-utils/src/test/java/io/fd/honeycomb/translate/util/read/registry/TypeHierarchyTest.java72
-rw-r--r--infra/translate-utils/src/test/java/io/fd/honeycomb/translate/util/write/registry/FlatWriterRegistryBuilderTest.java193
-rw-r--r--infra/translate-utils/src/test/java/io/fd/honeycomb/translate/util/write/registry/FlatWriterRegistryTest.java328
-rw-r--r--infra/translate-utils/src/test/java/io/fd/honeycomb/translate/util/write/registry/SubtreeWriterTest.java84
23 files changed, 120 insertions, 2617 deletions
diff --git a/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/AbstractGenericReader.java b/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/AbstractGenericReader.java
index 40c78b3c9..b19b72ecf 100644
--- a/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/AbstractGenericReader.java
+++ b/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/AbstractGenericReader.java
@@ -56,18 +56,15 @@ public abstract class AbstractGenericReader<D extends DataObject, B extends Buil
@Nonnull final ReadContext ctx) throws ReadFailedException {
LOG.debug("{}: Reading current: {}", this, id);
final B builder = getBuilder(id);
- // The empty value could be cached, but no caching is safer since we call overridden getBuilder each time
- // and the build could produce something different (even if it shouldn't)
- final D emptyValue = builder.build();
LOG.trace("{}: Reading current attributes", this);
readCurrentAttributes(id, builder, ctx);
// Need to check whether anything was filled in to determine if data is present or not.
final D built = builder.build();
- final Optional<D> read = built.equals(emptyValue)
- ? Optional.absent()
- : Optional.of(built);
+ final Optional<D> read = isPresent(id, built, ctx)
+ ? Optional.of(built)
+ : Optional.absent();
LOG.debug("{}: Current node read successfully. Result: {}", this, read);
return read;
diff --git a/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/BindingBrokerReader.java b/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/BindingBrokerReader.java
index b7a38e97f..e59e642c4 100644
--- a/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/BindingBrokerReader.java
+++ b/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/BindingBrokerReader.java
@@ -50,6 +50,11 @@ public final class BindingBrokerReader<D extends DataObject, B extends Builder<D
this.datastoreType = datastoreType;
}
+ @Override
+ public boolean isPresent(final InstanceIdentifier<D> id, final D built, final ReadContext ctx) {
+ throw new UnsupportedOperationException("Not supported");
+ }
+
@Nonnull
@Override
public Optional<? extends DataObject> read(@Nonnull final InstanceIdentifier<? extends DataObject> id,
diff --git a/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/DelegatingReader.java b/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/DelegatingReader.java
new file mode 100644
index 000000000..513639610
--- /dev/null
+++ b/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/DelegatingReader.java
@@ -0,0 +1,103 @@
+/*
+ * 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.translate.util.read;
+
+import com.google.common.base.Optional;
+import io.fd.honeycomb.translate.read.ListReader;
+import io.fd.honeycomb.translate.read.ReadContext;
+import io.fd.honeycomb.translate.read.ReadFailedException;
+import io.fd.honeycomb.translate.read.Reader;
+import java.util.List;
+import javax.annotation.Nonnull;
+import org.opendaylight.yangtools.concepts.Builder;
+import org.opendaylight.yangtools.yang.binding.DataObject;
+import org.opendaylight.yangtools.yang.binding.Identifiable;
+import org.opendaylight.yangtools.yang.binding.Identifier;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+/**
+ * A trait of a delegating reader. Delegates all the calls to its delegate.
+ */
+public interface DelegatingReader<D extends DataObject, B extends Builder<D>> extends Reader<D, B> {
+
+ Reader<D, B> getDelegate();
+
+ @Nonnull
+ default Optional<? extends DataObject> read(@Nonnull final InstanceIdentifier<? extends DataObject> id,
+ @Nonnull final ReadContext ctx) throws ReadFailedException {
+ return getDelegate().read(id, ctx);
+ }
+
+ default void readCurrentAttributes(@Nonnull final InstanceIdentifier<D> id,
+ @Nonnull final B builder,
+ @Nonnull final ReadContext ctx) throws ReadFailedException {
+ getDelegate().readCurrentAttributes(id, builder, ctx);
+ }
+
+ @Nonnull
+ default B getBuilder(final InstanceIdentifier<D> id) {
+ return getDelegate().getBuilder(id);
+ }
+
+ default void merge(@Nonnull final Builder<? extends DataObject> parentBuilder,
+ @Nonnull final D readValue) {
+ getDelegate().merge(parentBuilder, readValue);
+ }
+
+ @Override
+ default boolean isPresent(InstanceIdentifier<D> id, D built, final ReadContext ctx) throws ReadFailedException {
+ return getDelegate().isPresent(id, built, ctx);
+ }
+
+ @Nonnull
+ default InstanceIdentifier<D> getManagedDataObjectType() {
+ return getDelegate().getManagedDataObjectType();
+ }
+
+ /**
+ * ListReader specific delegating trait.
+ */
+ interface DelegatingListReader<D extends DataObject & Identifiable<K>, K extends Identifier<D>, B extends Builder<D>>
+ extends DelegatingReader<D, B>, ListReader<D, K, B> {
+
+ ListReader<D, K, B> getDelegate();
+
+ @Override
+ default List<K> getAllIds(@Nonnull InstanceIdentifier<D> id, @Nonnull ReadContext ctx)
+ throws ReadFailedException {
+ return getDelegate().getAllIds(id, ctx);
+ }
+
+ @Nonnull
+ @Override
+ default List<D> readList(@Nonnull final InstanceIdentifier<D> id, @Nonnull final ReadContext ctx)
+ throws ReadFailedException {
+ return getDelegate().readList(id, ctx);
+ }
+
+ @Override
+ default void merge(@Nonnull final Builder<? extends DataObject> builder,
+ @Nonnull final List<D> readData) {
+ getDelegate().merge(builder, readData);
+ }
+
+ @Override
+ default void merge(@Nonnull final Builder<? extends DataObject> parentBuilder, @Nonnull final D readValue) {
+ getDelegate().merge(parentBuilder, readValue);
+ }
+ }
+}
diff --git a/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/KeepaliveReaderWrapper.java b/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/KeepaliveReaderWrapper.java
index 5ab9bc59e..9a695a53c 100644
--- a/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/KeepaliveReaderWrapper.java
+++ b/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/KeepaliveReaderWrapper.java
@@ -18,11 +18,10 @@ package io.fd.honeycomb.translate.util.read;
import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
-import io.fd.honeycomb.translate.read.ReadContext;
-import io.fd.honeycomb.translate.read.Reader;
import io.fd.honeycomb.translate.MappingContext;
import io.fd.honeycomb.translate.ModificationCache;
-import io.fd.honeycomb.translate.read.ReadFailedException;
+import io.fd.honeycomb.translate.read.ReadContext;
+import io.fd.honeycomb.translate.read.Reader;
import java.io.Closeable;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;
@@ -40,7 +39,7 @@ import org.slf4j.LoggerFactory;
* In case a specific error occurs, Keep-alive failure listener gets notified.
*/
public final class KeepaliveReaderWrapper<D extends DataObject, B extends Builder<D>>
- implements Reader<D, B>, Runnable, Closeable {
+ implements DelegatingReader<D, B>,Runnable, Closeable {
private static final Logger LOG = LoggerFactory.getLogger(KeepaliveReaderWrapper.class);
@@ -73,34 +72,6 @@ public final class KeepaliveReaderWrapper<D extends DataObject, B extends Builde
scheduledFuture = executor.scheduleWithFixedDelay(this, delayInSeconds, delayInSeconds, TimeUnit.SECONDS);
}
- @Nonnull
- public Optional<? extends DataObject> read(@Nonnull final InstanceIdentifier id,
- @Nonnull final ReadContext ctx) throws ReadFailedException {
- return delegate.read(id, ctx);
- }
-
- public void readCurrentAttributes(@Nonnull final InstanceIdentifier<D> id,
- @Nonnull final B builder,
- @Nonnull final ReadContext ctx) throws ReadFailedException {
- delegate.readCurrentAttributes(id, builder, ctx);
- }
-
- @Nonnull
- public B getBuilder(final InstanceIdentifier<D> id) {
- return delegate.getBuilder(id);
- }
-
- public void merge(@Nonnull final Builder<? extends DataObject> parentBuilder,
- @Nonnull final D readValue) {
- delegate.merge(parentBuilder, readValue);
- }
-
- @Nonnull
- @Override
- public InstanceIdentifier<D> getManagedDataObjectType() {
- return delegate.getManagedDataObjectType();
- }
-
@Override
public void run() {
LOG.trace("Invoking keepalive");
@@ -123,6 +94,11 @@ public final class KeepaliveReaderWrapper<D extends DataObject, B extends Builde
scheduledFuture.cancel(false);
}
+ @Override
+ public Reader<D, B> getDelegate() {
+ return delegate;
+ }
+
/**
* Listener that gets called whenever keepalive fails as expected.
*/
diff --git a/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/ReflexiveReader.java b/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/ReflexiveReader.java
deleted file mode 100644
index 2aa35514e..000000000
--- a/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/ReflexiveReader.java
+++ /dev/null
@@ -1,57 +0,0 @@
-/*
- * 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.translate.util.read;
-
-import io.fd.honeycomb.translate.read.ReadContext;
-import io.fd.honeycomb.translate.read.ReadFailedException;
-import javax.annotation.Nonnull;
-import org.opendaylight.yangtools.concepts.Builder;
-import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-
-/**
- * Reader that performs no read operation on its own, just fills in the hierarchy.
- * <p/>
- * Might be slow due to reflection !
- */
-public class ReflexiveReader<C extends DataObject, B extends Builder<C>> extends AbstractGenericReader<C, B> {
-
- private final ReflexiveReaderCustomizer<C, B> customizer;
-
- public ReflexiveReader(final InstanceIdentifier<C> identifier, final Class<B> builderClass) {
- super(identifier);
- this.customizer = new ReflexiveReaderCustomizer<>(identifier.getTargetType(), builderClass);
- }
-
- @Override
- public void readCurrentAttributes(@Nonnull final InstanceIdentifier<C> id, @Nonnull final B builder,
- @Nonnull final ReadContext ctx)
- throws ReadFailedException {
- customizer.readCurrentAttributes(id, builder, ctx);
- }
-
- @Nonnull
- @Override
- public B getBuilder(final InstanceIdentifier<C> id) {
- return customizer.getBuilder(id);
- }
-
- @Override
- public void merge(@Nonnull final Builder<? extends DataObject> parentBuilder, @Nonnull final C readValue) {
- customizer.merge(parentBuilder, readValue);
- }
-}
diff --git a/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/ReflexiveReaderCustomizer.java b/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/ReflexiveReaderCustomizer.java
index 18e6285f3..087873306 100644
--- a/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/ReflexiveReaderCustomizer.java
+++ b/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/ReflexiveReaderCustomizer.java
@@ -33,7 +33,7 @@ import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
/**
* Might be slow.
*/
-class ReflexiveReaderCustomizer<C extends DataObject, B extends Builder<C>> extends NoopReaderCustomizer<C, B> {
+public class ReflexiveReaderCustomizer<C extends DataObject, B extends Builder<C>> extends NoopReaderCustomizer<C, B> {
private final Class<C> typeClass;
private final Class<B> builderClass;
diff --git a/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/registry/CompositeReader.java b/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/registry/CompositeReader.java
deleted file mode 100644
index b52fd09ec..000000000
--- a/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/registry/CompositeReader.java
+++ /dev/null
@@ -1,241 +0,0 @@
-/*
- * 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.translate.util.read.registry;
-
-import static com.google.common.base.Preconditions.checkArgument;
-
-import com.google.common.annotations.VisibleForTesting;
-import com.google.common.base.Optional;
-import com.google.common.collect.ImmutableMap;
-import com.google.common.collect.Iterables;
-import io.fd.honeycomb.translate.read.InitFailedException;
-import io.fd.honeycomb.translate.read.InitListReader;
-import io.fd.honeycomb.translate.read.Initializer;
-import io.fd.honeycomb.translate.read.ListReader;
-import io.fd.honeycomb.translate.read.ReadContext;
-import io.fd.honeycomb.translate.read.ReadFailedException;
-import io.fd.honeycomb.translate.read.Reader;
-import io.fd.honeycomb.translate.util.RWUtils;
-import io.fd.honeycomb.translate.util.read.AbstractGenericReader;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-import javax.annotation.Nonnull;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.yangtools.concepts.Builder;
-import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.Identifiable;
-import org.opendaylight.yangtools.yang.binding.Identifier;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-class CompositeReader<D extends DataObject, B extends Builder<D>>
- extends AbstractGenericReader<D, B>
- implements Initializer<D> {
-
- private static final Logger LOG = LoggerFactory.getLogger(CompositeReader.class);
-
- private final Reader<D, B> delegate;
- private final ImmutableMap<Class<?>, Reader<? extends DataObject, ? extends Builder<?>>> childReaders;
-
- private CompositeReader(final Reader<D, B> reader,
- final ImmutableMap<Class<?>, Reader<? extends DataObject, ? extends Builder<?>>> childReaders) {
- super(reader.getManagedDataObjectType());
- this.delegate = reader;
- this.childReaders = childReaders;
- }
-
- @VisibleForTesting
- ImmutableMap<Class<?>, Reader<? extends DataObject, ? extends Builder<?>>> getChildReaders() {
- return childReaders;
- }
-
- @SuppressWarnings("unchecked")
- public static <D extends DataObject> InstanceIdentifier<D> appendTypeToId(
- final InstanceIdentifier<? extends DataObject> parentId, final InstanceIdentifier<D> type) {
- final InstanceIdentifier.PathArgument t = new InstanceIdentifier.Item<>(type.getTargetType());
- return (InstanceIdentifier<D>) InstanceIdentifier.create(Iterables.concat(
- parentId.getPathArguments(), Collections.singleton(t)));
- }
-
- @Nonnull
- @Override
- public Optional<? extends DataObject> read(@Nonnull final InstanceIdentifier<? extends DataObject> id,
- @Nonnull final ReadContext ctx) throws ReadFailedException {
- if (shouldReadCurrent(id)) {
- LOG.trace("{}: Reading current: {}", this, id);
- return readCurrent((InstanceIdentifier<D>) id, ctx);
- } else if (shouldDelegateToChild(id)) {
- LOG.trace("{}: Reading child: {}", this, id);
- return readSubtree(id, ctx);
- } else {
- // Fallback
- LOG.trace("{}: Delegating read: {}", this, id);
- return delegate.read(id, ctx);
- }
- }
-
- private boolean shouldReadCurrent(@Nonnull final InstanceIdentifier<? extends DataObject> id) {
- return id.getTargetType().equals(getManagedDataObjectType().getTargetType());
- }
-
- private boolean shouldDelegateToChild(@Nonnull final InstanceIdentifier<? extends DataObject> id) {
- return childReaders.containsKey(RWUtils.getNextId(id, getManagedDataObjectType()).getType());
- }
-
- private Optional<? extends DataObject> readSubtree(final InstanceIdentifier<? extends DataObject> id,
- final ReadContext ctx) throws ReadFailedException {
- final InstanceIdentifier.PathArgument nextId = RWUtils.getNextId(id, getManagedDataObjectType());
- final Reader<?, ? extends Builder<?>> nextReader = childReaders.get(nextId.getType());
- checkArgument(nextReader != null, "Unable to read: %s. No delegate present, available readers at next level: %s",
- id, childReaders.keySet());
- return nextReader.read(id, ctx);
- }
-
- @SuppressWarnings("unchecked")
- private void readChildren(final InstanceIdentifier<D> id, @Nonnull final ReadContext ctx, final B builder)
- throws ReadFailedException {
- LOG.debug("{}: Reading children: {}", this, childReaders.keySet());
- for (Reader child : childReaders.values()) {
- final InstanceIdentifier childId = appendTypeToId(id, child.getManagedDataObjectType());
-
- LOG.debug("{}: Reading child from: {}", this, child);
- if (child instanceof ListReader) {
- final List<? extends DataObject> list = ((ListReader) child).readList(childId, ctx);
- // Dont set empty lists
- if (!list.isEmpty()) {
- ((ListReader) child).merge(builder, list);
- }
- } else {
- final Optional<? extends DataObject> read = child.read(childId, ctx);
- if (read.isPresent()) {
- child.merge(builder, read.get());
- }
- }
- }
- }
-
- @Override
- public void readCurrentAttributes(@Nonnull final InstanceIdentifier<D> id, @Nonnull final B builder,
- @Nonnull final ReadContext ctx)
- throws ReadFailedException {
- delegate.readCurrentAttributes(id, builder, ctx);
- readChildren(id, ctx, builder);
- }
-
- @Nonnull
- @Override
- public B getBuilder(final InstanceIdentifier<D> id) {
- return delegate.getBuilder(id);
- }
-
- @Override
- public void merge(@Nonnull final Builder<? extends DataObject> parentBuilder, @Nonnull final D readValue) {
- delegate.merge(parentBuilder, readValue);
- }
-
- /**
- * Wrap a Reader as a Composite Reader.
- */
- static <D extends DataObject, B extends Builder<D>> Reader<D, B> createForReader(
- @Nonnull final Reader<D, B> reader,
- @Nonnull final ImmutableMap<Class<?>, Reader<?, ? extends Builder<?>>> childReaders) {
-
- return (reader instanceof ListReader)
- ? new CompositeListReader<>((ListReader) reader, childReaders)
- : new CompositeReader<>(reader, childReaders);
- }
-
- @SuppressWarnings("unchecked")
- @Override
- public void init(final DataBroker broker, final InstanceIdentifier<D> id, final ReadContext ctx) throws InitFailedException {
- if (delegate instanceof Initializer) {
- LOG.trace("{}: Initializing current: {}", this, id);
- ((Initializer<D>) delegate).init(broker, id, ctx);
- }
-
- for (Reader child : childReaders.values()) {
- final InstanceIdentifier childId = appendTypeToId(id, child.getManagedDataObjectType());
-
- if (child instanceof Initializer) {
- LOG.trace("{}: Initializing child: {}", this, childId);
- ((Initializer) child).init(broker, childId, ctx);
- }
- }
- }
-
- private static class CompositeListReader<D extends DataObject & Identifiable<K>, B extends Builder<D>, K extends Identifier<D>>
- extends CompositeReader<D, B>
- implements InitListReader<D, K, B> {
-
- private final ListReader<D, K, B> delegate;
-
- private CompositeListReader(final ListReader<D, K, B> reader,
- final ImmutableMap<Class<?>, Reader<? extends DataObject, ? extends Builder<?>>> childReaders) {
- super(reader, childReaders);
- this.delegate = reader;
- }
-
- @Nonnull
- @Override
- public List<D> readList(@Nonnull final InstanceIdentifier<D> id, @Nonnull final ReadContext ctx)
- throws ReadFailedException {
- LOG.trace("{}: Reading all list entries", this);
- final List<K> allIds = delegate.getAllIds(id, ctx);
- LOG.debug("{}: Reading list entries for: {}", this, allIds);
-
- // Override read list in order to perform readCurrent + readChildren here
- final ArrayList<D> allEntries = new ArrayList<>(allIds.size());
- for (K key : allIds) {
- final InstanceIdentifier.IdentifiableItem<D, K> currentBdItem = RWUtils.getCurrentIdItem(id, key);
- final InstanceIdentifier<D> keyedId = RWUtils.replaceLastInId(id, currentBdItem);
- final Optional<D> read = readCurrent(keyedId, ctx);
- if (read.isPresent()) {
- final DataObject singleItem = read.get();
- checkArgument(getManagedDataObjectType().getTargetType().isAssignableFrom(singleItem.getClass()));
- allEntries.add(getManagedDataObjectType().getTargetType().cast(singleItem));
- }
- }
- return allEntries;
- }
-
- @Override
- public void init(final DataBroker broker, final InstanceIdentifier<D> id, final ReadContext ctx)
- throws InitFailedException {
- try {
- final List<K> allIds = delegate.getAllIds(id, ctx);
- for (K key : allIds) {
- super.init(broker, RWUtils.replaceLastInId(id, RWUtils.getCurrentIdItem(id, key)), ctx);
- }
- } catch (ReadFailedException e) {
- throw new InitFailedException(id, e);
- }
- }
-
- @Override
- public void merge(@Nonnull final Builder<? extends DataObject> builder, @Nonnull final List<D> readData) {
- delegate.merge(builder, readData);
- }
-
- @Override
- public List<K> getAllIds(@Nonnull final InstanceIdentifier<D> id,
- @Nonnull final ReadContext ctx) throws ReadFailedException {
- return delegate.getAllIds(id, ctx);
- }
- }
-}
diff --git a/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/registry/CompositeReaderRegistry.java b/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/registry/CompositeReaderRegistry.java
deleted file mode 100644
index 9505a7730..000000000
--- a/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/registry/CompositeReaderRegistry.java
+++ /dev/null
@@ -1,131 +0,0 @@
-/*
- * 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.translate.util.read.registry;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-
-import com.google.common.annotations.VisibleForTesting;
-import com.google.common.base.Optional;
-import com.google.common.collect.Iterables;
-import com.google.common.collect.LinkedListMultimap;
-import com.google.common.collect.Multimap;
-import io.fd.honeycomb.translate.read.InitFailedException;
-import io.fd.honeycomb.translate.read.Initializer;
-import io.fd.honeycomb.translate.read.ListReader;
-import io.fd.honeycomb.translate.read.ReadContext;
-import io.fd.honeycomb.translate.read.ReadFailedException;
-import io.fd.honeycomb.translate.read.Reader;
-import io.fd.honeycomb.translate.read.registry.ReaderRegistry;
-import io.fd.honeycomb.translate.util.RWUtils;
-import java.util.Collections;
-import java.util.List;
-import java.util.Map;
-import java.util.stream.Collectors;
-import javax.annotation.Nonnull;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.yangtools.concepts.Builder;
-import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-/**
- * Simple reader registry able to perform and aggregated read (ROOT read) on top of all provided readers. Also able to
- * delegate a specific read to one of the delegate readers.
- * <p/>
- * This could serve as a utility to hold & hide all available readers in upper layers.
- */
-public final class CompositeReaderRegistry implements ReaderRegistry {
-
- private static final Logger LOG = LoggerFactory.getLogger(CompositeReaderRegistry.class);
-
- private final Map<Class<? extends DataObject>, Reader<? extends DataObject, ? extends Builder<?>>> rootReaders;
-
- /**
- * Create new {@link CompositeReaderRegistry}.
- *
- * @param rootReaders List of delegate readers
- */
- public CompositeReaderRegistry(@Nonnull final List<Reader<? extends DataObject, ? extends Builder<?>>> rootReaders) {
- this.rootReaders = RWUtils.uniqueLinkedIndex(checkNotNull(rootReaders), RWUtils.MANAGER_CLASS_FUNCTION);
- }
-
- @VisibleForTesting
- Map<Class<? extends DataObject>, Reader<? extends DataObject, ? extends Builder<?>>> getRootReaders() {
- return rootReaders;
- }
-
- @Override
- @Nonnull
- 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());
-
- final Multimap<InstanceIdentifier<? extends DataObject>, DataObject> objects = LinkedListMultimap.create();
- for (Reader<? extends DataObject, ? extends Builder<?>> rootReader : rootReaders.values()) {
- LOG.debug("Reading from delegate: {}", rootReader);
-
- if (rootReader instanceof ListReader) {
- final List<? extends DataObject> listEntries =
- ((ListReader) rootReader).readList(rootReader.getManagedDataObjectType(), ctx);
- if (!listEntries.isEmpty()) {
- objects.putAll(rootReader.getManagedDataObjectType(), listEntries);
- }
- } else {
- final Optional<? extends DataObject> read = rootReader.read(rootReader.getManagedDataObjectType(), ctx);
- if (read.isPresent()) {
- objects.putAll(rootReader.getManagedDataObjectType(), Collections.singletonList(read.get()));
- }
- }
- }
-
- return objects;
- }
-
-
- @Override
- public void initAll(@Nonnull final DataBroker broker, @Nonnull final ReadContext ctx) throws InitFailedException {
- for (Reader<? extends DataObject, ? extends Builder<?>> rootReader : rootReaders.values()) {
- if (rootReader instanceof Initializer<?>) {
- ((Initializer) rootReader).init(broker, rootReader.getManagedDataObjectType(), ctx);
- }
- }
- }
-
- @Nonnull
- @Override
- 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");
- final Reader<? extends DataObject, ? extends Builder<?>> reader = rootReaders.get(first.getType());
- checkNotNull(reader,
- "Unable to read %s. Missing reader. Current readers for: %s", id, rootReaders.keySet());
- LOG.debug("Reading from delegate: {}", reader);
- return reader.read(id, ctx);
- }
-
- @Override
- public String toString() {
- return getClass().getSimpleName()
- + rootReaders.keySet().stream().map(Class::getSimpleName).collect(Collectors.toList());
- }
-
-}
diff --git a/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/registry/CompositeReaderRegistryBuilder.java b/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/registry/CompositeReaderRegistryBuilder.java
deleted file mode 100644
index da9bbe934..000000000
--- a/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/registry/CompositeReaderRegistryBuilder.java
+++ /dev/null
@@ -1,114 +0,0 @@
-/*
- * 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.translate.util.read.registry;
-
-import com.google.common.collect.ImmutableMap;
-import io.fd.honeycomb.translate.read.InitReader;
-import io.fd.honeycomb.translate.read.Reader;
-import io.fd.honeycomb.translate.read.registry.ModifiableReaderRegistryBuilder;
-import io.fd.honeycomb.translate.read.registry.ReaderRegistry;
-import io.fd.honeycomb.translate.read.registry.ReaderRegistryBuilder;
-import io.fd.honeycomb.translate.util.AbstractSubtreeManagerRegistryBuilderBuilder;
-import io.fd.honeycomb.translate.util.read.ReflexiveReader;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Set;
-import java.util.stream.Collectors;
-import javax.annotation.Nonnull;
-import javax.annotation.concurrent.NotThreadSafe;
-import org.opendaylight.yangtools.concepts.Builder;
-import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-@NotThreadSafe
-public final class CompositeReaderRegistryBuilder
- extends AbstractSubtreeManagerRegistryBuilderBuilder<Reader<? extends DataObject, ? extends Builder<?>>, ReaderRegistry>
- implements ModifiableReaderRegistryBuilder, ReaderRegistryBuilder {
-
- private static final Logger LOG = LoggerFactory.getLogger(CompositeReaderRegistryBuilder.class);
-
- @Override
- protected Reader<? extends DataObject, ? extends Builder<?>> getSubtreeHandler(@Nonnull final Set<InstanceIdentifier<?>> handledChildren,
- @Nonnull final Reader<? extends DataObject, ? extends Builder<?>> reader) {
- return reader instanceof InitReader
- ? InitSubtreeReader.createForReader(handledChildren, reader)
- : SubtreeReader.createForReader(handledChildren, reader);
- }
-
- @Override
- public <D extends DataObject> void addStructuralReader(@Nonnull InstanceIdentifier<D> id,
- @Nonnull Class<? extends Builder<D>> builderType) {
- add(new ReflexiveReader<>(id, builderType));
- }
-
-
-
- /**
- * Create {@link CompositeReaderRegistry} with Readers ordered according to submitted relationships.
- * <p/>
- * Note: The ordering only applies between nodes on the same level, inter-level and inter-subtree relationships are
- * ignored.
- */
- @Override
- public ReaderRegistry build() {
- ImmutableMap<InstanceIdentifier<?>, Reader<? extends DataObject, ? extends Builder<?>>> mappedReaders =
- getMappedHandlers();
- LOG.debug("Building Reader registry with Readers: {}",
- mappedReaders.keySet().stream()
- .map(InstanceIdentifier::getTargetType)
- .map(Class::getSimpleName)
- .collect(Collectors.joining(", ")));
-
- LOG.trace("Building Reader registry with Readers: {}", mappedReaders);
- final List<InstanceIdentifier<?>> readerOrder = new ArrayList<>(mappedReaders.keySet());
-
- // Wrap readers into composite readers recursively, collect roots and create registry
- final TypeHierarchy typeHierarchy = TypeHierarchy.create(mappedReaders.keySet());
- final List<Reader<? extends DataObject, ? extends Builder<?>>> orderedRootReaders =
- typeHierarchy.getRoots().stream()
- .map(rootId -> toCompositeReader(rootId, mappedReaders, typeHierarchy))
- .collect(Collectors.toList());
-
- // We are violating the ordering from mappedReaders, since we are forming a composite structure
- // but at least order root writers
- orderedRootReaders.sort((reader1, reader2) -> readerOrder.indexOf(reader1.getManagedDataObjectType())
- - readerOrder.indexOf(reader2.getManagedDataObjectType()));
-
- return new CompositeReaderRegistry(orderedRootReaders);
- }
-
- private Reader<? extends DataObject, ? extends Builder<?>> toCompositeReader(
- final InstanceIdentifier<?> instanceIdentifier,
- final ImmutableMap<InstanceIdentifier<?>, Reader<? extends DataObject, ? extends Builder<?>>> mappedReaders,
- final TypeHierarchy typeHierarchy) {
-
- // Order child readers according to the mappedReadersCollection
- final ImmutableMap.Builder<Class<?>, Reader<?, ? extends Builder<?>>> childReadersMapB = ImmutableMap.builder();
- for (InstanceIdentifier<?> childId : mappedReaders.keySet()) {
- if (typeHierarchy.getDirectChildren(instanceIdentifier).contains(childId)) {
- childReadersMapB.put(childId.getTargetType(), toCompositeReader(childId, mappedReaders, typeHierarchy));
- }
- }
-
- final ImmutableMap<Class<?>, Reader<?, ? extends Builder<?>>> childReadersMap = childReadersMapB.build();
- return childReadersMap.isEmpty()
- ? mappedReaders.get(instanceIdentifier)
- : CompositeReader.createForReader(mappedReaders.get(instanceIdentifier), childReadersMap);
- }
-}
diff --git a/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/registry/InitSubtreeReader.java b/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/registry/InitSubtreeReader.java
deleted file mode 100644
index 4edc38f9d..000000000
--- a/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/registry/InitSubtreeReader.java
+++ /dev/null
@@ -1,72 +0,0 @@
-/*
- * 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.translate.util.read.registry;
-
-import io.fd.honeycomb.translate.read.InitFailedException;
-import io.fd.honeycomb.translate.read.InitListReader;
-import io.fd.honeycomb.translate.read.InitReader;
-import io.fd.honeycomb.translate.read.ListReader;
-import io.fd.honeycomb.translate.read.ReadContext;
-import io.fd.honeycomb.translate.read.Reader;
-import java.util.Set;
-import javax.annotation.Nonnull;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.yangtools.concepts.Builder;
-import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.Identifiable;
-import org.opendaylight.yangtools.yang.binding.Identifier;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-
-class InitSubtreeReader<O extends DataObject, B extends Builder<O>>
- extends SubtreeReader<O, B>
- implements InitReader<O, B> {
-
- private InitSubtreeReader(final InitReader<O, B> delegate,
- final Set<InstanceIdentifier<?>> handledTypes) {
- super(delegate, handledTypes);
- }
-
- @Override
- public void init(final DataBroker broker, final InstanceIdentifier<O> id, final ReadContext ctx) throws InitFailedException {
- ((InitReader<O, B>) delegate).init(broker, id, ctx);
- }
-
- /**
- * Wrap a Reader as an initializing subtree Reader.
- */
- static <D extends DataObject, B extends Builder<D>> Reader<D, B> createForReader(@Nonnull final Set<InstanceIdentifier<?>> handledChildren,
- @Nonnull final Reader<D, B> reader) {
- return (reader instanceof ListReader)
- ? new InitSubtreeListReader<>((InitListReader) reader, handledChildren)
- : new InitSubtreeReader<>(((InitReader<D, B>) reader), handledChildren);
- }
-
- private static class InitSubtreeListReader<D extends DataObject & Identifiable<K>, B extends Builder<D>, K extends Identifier<D>>
- extends SubtreeListReader<D, B, K>
- implements InitListReader<D, K, B> {
-
- InitSubtreeListReader(final InitListReader<D, K, B> delegate,
- final Set<InstanceIdentifier<?>> handledTypes) {
- super(delegate, handledTypes);
- }
-
- @Override
- public void init(final DataBroker broker, final InstanceIdentifier<D> id, final ReadContext ctx) throws InitFailedException {
- ((InitListReader<D, K, B>) delegate).init(broker, id, ctx);
- }
- }
-}
diff --git a/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/registry/SubtreeReader.java b/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/registry/SubtreeReader.java
deleted file mode 100644
index 3bc76b19a..000000000
--- a/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/registry/SubtreeReader.java
+++ /dev/null
@@ -1,241 +0,0 @@
-/*
- * 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.translate.util.read.registry;
-
-import static com.google.common.base.Preconditions.checkArgument;
-
-import com.google.common.base.Optional;
-import com.google.common.collect.Iterables;
-import io.fd.honeycomb.translate.read.ListReader;
-import io.fd.honeycomb.translate.read.ReadContext;
-import io.fd.honeycomb.translate.read.ReadFailedException;
-import io.fd.honeycomb.translate.read.Reader;
-import io.fd.honeycomb.translate.util.RWUtils;
-import io.fd.honeycomb.translate.util.ReflectionUtils;
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
-import java.util.Collections;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Set;
-import javax.annotation.Nonnull;
-import org.opendaylight.yangtools.concepts.Builder;
-import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.Identifiable;
-import org.opendaylight.yangtools.yang.binding.Identifier;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-/**
- * Simple Reader delegate for subtree Readers (Readers handling also children nodes) providing a list of all the
- * children nodes being handled.
- */
-class SubtreeReader<D extends DataObject, B extends Builder<D>> implements Reader<D, B> {
-
- private static final Logger LOG = LoggerFactory.getLogger(SubtreeReader.class);
-
- protected final Reader<D, B> delegate;
- private final Set<InstanceIdentifier<?>> handledChildTypes = new HashSet<>();
-
- SubtreeReader(final Reader<D, B> delegate, Set<InstanceIdentifier<?>> handledTypes) {
- this.delegate = delegate;
- for (InstanceIdentifier<?> handledType : handledTypes) {
- // Iid has to start with Reader's handled root type
- checkArgument(delegate.getManagedDataObjectType().getTargetType().equals(
- handledType.getPathArguments().iterator().next().getType()),
- "Handled node from subtree has to be identified by an instance identifier starting from: %s."
- + "Instance identifier was: %s", getManagedDataObjectType().getTargetType(), handledType);
- checkArgument(Iterables.size(handledType.getPathArguments()) > 1,
- "Handled node from subtree identifier too short: %s", handledType);
- handledChildTypes.add(InstanceIdentifier.create(Iterables.concat(
- getManagedDataObjectType().getPathArguments(), Iterables.skip(handledType.getPathArguments(), 1))));
- }
- }
-
- /**
- * Return set of types also handled by this Reader. All of the types are children of the type managed by this Reader
- * excluding the type of this Reader.
- */
- Set<InstanceIdentifier<?>> getHandledChildTypes() {
- return handledChildTypes;
- }
-
- @Override
- @Nonnull
- public Optional<? extends DataObject> read(
- @Nonnull final InstanceIdentifier<? extends DataObject> id,
- @Nonnull final ReadContext ctx) throws ReadFailedException {
- final InstanceIdentifier<?> wildcarded = RWUtils.makeIidWildcarded(id);
-
- // Reading entire subtree and filtering if is current reader responsible
- if (getHandledChildTypes().contains(wildcarded)) {
- LOG.debug("{}: Subtree node managed by this writer requested: {}. Reading current and filtering", this, id);
- // If there's no dedicated reader, use read current
- final InstanceIdentifier<D> currentId = RWUtils.cutId(id, getManagedDataObjectType());
- final Optional<? extends DataObject> current = delegate.read(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())
- : current;
-
- LOG.debug("{}: Subtree: {} read successfully. Result: {}", this, id, readSubtree);
- return readSubtree;
-
- // If child that's handled here is not requested, then delegate should be able to handle the read
- } else {
- return delegate.read(id, ctx);
- }
- }
-
- @Override
- public void readCurrentAttributes(@Nonnull final InstanceIdentifier<D> id, @Nonnull final B builder,
- @Nonnull final ReadContext ctx)
- throws ReadFailedException {
- delegate.readCurrentAttributes(id, builder, ctx);
- }
-
- @Nonnull
- @Override
- public B getBuilder(final InstanceIdentifier<D> id) {
- return delegate.getBuilder(id);
- }
-
- @Override
- public void merge(@Nonnull final Builder<? extends DataObject> parentBuilder, @Nonnull final D readValue) {
- delegate.merge(parentBuilder, readValue);
- }
-
- @Nonnull
- private static Optional<? extends DataObject> filterSubtree(@Nonnull final DataObject parent,
- @Nonnull final InstanceIdentifier<? extends DataObject> absolutPath,
- @Nonnull final Class<?> managedType) {
- final InstanceIdentifier.PathArgument nextId =
- RWUtils.getNextId(absolutPath, InstanceIdentifier.create(parent.getClass()));
-
- final Optional<? extends DataObject> nextParent = findNextParent(parent, nextId, managedType);
-
- if (Iterables.getLast(absolutPath.getPathArguments()).equals(nextId)) {
- return nextParent; // we found the dataObject identified by absolutePath
- } else if (nextParent.isPresent()) {
- return filterSubtree(nextParent.get(), absolutPath, nextId.getType());
- } else {
- return nextParent; // we can't go further, return Optional.absent()
- }
- }
-
- private static Optional<? extends DataObject> findNextParent(@Nonnull final DataObject parent,
- @Nonnull final InstanceIdentifier.PathArgument nextId,
- @Nonnull final Class<?> managedType) {
- Optional<Method> method = ReflectionUtils.findMethodReflex(managedType, "get",
- Collections.emptyList(), nextId.getType());
-
- if (method.isPresent()) {
- return Optional.fromNullable(filterSingle(parent, nextId, method.get()));
- } else {
- // List child nodes
- method = ReflectionUtils.findMethodReflex(managedType,
- "get" + nextId.getType().getSimpleName(), Collections.emptyList(), List.class);
-
- if (method.isPresent()) {
- return filterList(parent, nextId, method.get());
- } else {
- throw new IllegalStateException(
- "Unable to filter " + nextId + " from " + parent + " getters not found using reflexion");
- }
- }
- }
-
- @SuppressWarnings("unchecked")
- private static Optional<? extends DataObject> filterList(final DataObject parent,
- final InstanceIdentifier.PathArgument nextId,
- final Method method) {
- final List<? extends DataObject> invoke = (List<? extends DataObject>) invoke(method, nextId, parent);
-
- checkArgument(nextId instanceof InstanceIdentifier.IdentifiableItem<?, ?>,
- "Unable to perform wildcarded read for %s", nextId);
- final Identifier key = ((InstanceIdentifier.IdentifiableItem) nextId).getKey();
-
- final Method keyGetter = ReflectionUtils.findMethodReflex(nextId.getType(), "get",
- Collections.emptyList(), key.getClass()).get();
-
- return Optional.fromNullable(invoke.stream()
- .filter(item -> key.equals(invoke(keyGetter, nextId, item)))
- .findFirst().orElse(null));
- }
-
- private static DataObject filterSingle(final DataObject parent,
- final InstanceIdentifier.PathArgument nextId, final Method method) {
- return nextId.getType().cast(invoke(method, nextId, parent));
- }
-
- private static Object invoke(final Method method,
- final InstanceIdentifier.PathArgument nextId, final DataObject parent) {
- try {
- return method.invoke(parent);
- } catch (IllegalAccessException | InvocationTargetException e) {
- throw new IllegalArgumentException("Unable to get " + nextId + " from " + parent, e);
- }
- }
-
- @Override
- @Nonnull
- public InstanceIdentifier<D> getManagedDataObjectType() {
- return delegate.getManagedDataObjectType();
- }
-
- /**
- * Wrap a Reader as a subtree Reader.
- */
- static <D extends DataObject, B extends Builder<D>> Reader<D, B> createForReader(@Nonnull final Set<InstanceIdentifier<?>> handledChildren,
- @Nonnull final Reader<D, B> reader) {
- return (reader instanceof ListReader)
- ? new SubtreeListReader<>((ListReader) reader, handledChildren)
- : new SubtreeReader<>(reader, handledChildren);
- }
-
- static class SubtreeListReader<D extends DataObject & Identifiable<K>, B extends Builder<D>, K extends Identifier<D>>
- extends SubtreeReader<D, B> implements ListReader<D, K, B> {
-
- final ListReader<D, K, B> delegate;
-
- SubtreeListReader(final ListReader<D, K, B> delegate,
- final Set<InstanceIdentifier<?>> handledTypes) {
- super(delegate, handledTypes);
- this.delegate = delegate;
- }
-
- @Nonnull
- @Override
- public List<D> readList(@Nonnull final InstanceIdentifier<D> id, @Nonnull final ReadContext ctx)
- throws ReadFailedException {
- return delegate.readList(id, ctx);
- }
-
- @Override
- public void merge(@Nonnull final Builder<? extends DataObject> builder, @Nonnull final List<D> readData) {
- delegate.merge(builder, readData);
- }
-
- @Override
- public List<K> getAllIds(@Nonnull final InstanceIdentifier<D> id,
- @Nonnull final ReadContext ctx) throws ReadFailedException {
- return delegate.getAllIds(id, ctx);
- }
- }
-
-}
diff --git a/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/registry/TypeHierarchy.java b/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/registry/TypeHierarchy.java
deleted file mode 100644
index a30663221..000000000
--- a/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/registry/TypeHierarchy.java
+++ /dev/null
@@ -1,101 +0,0 @@
-/*
- * 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.translate.util.read.registry;
-
-import static com.google.common.base.Preconditions.checkArgument;
-
-import com.google.common.collect.Iterables;
-import java.util.HashSet;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.Set;
-import java.util.stream.Collectors;
-import javax.annotation.Nonnull;
-import org.jgrapht.experimental.dag.DirectedAcyclicGraph;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-
-final class TypeHierarchy {
- private final DirectedAcyclicGraph<InstanceIdentifier<?>, Parent> hierarchy;
-
- private TypeHierarchy(@Nonnull final DirectedAcyclicGraph<InstanceIdentifier<?>, Parent> hierarchy) {
- this.hierarchy = hierarchy;
- }
-
- Set<InstanceIdentifier<?>> getAllChildren(InstanceIdentifier<?> id) {
- final HashSet<InstanceIdentifier<?>> instanceIdentifiers = new HashSet<>();
- for (InstanceIdentifier<?> childId : getDirectChildren(id)) {
- instanceIdentifiers.add(childId);
- instanceIdentifiers.addAll(getAllChildren(childId));
- }
- return instanceIdentifiers;
- }
-
- Set<InstanceIdentifier<?>> getDirectChildren(InstanceIdentifier<?> id) {
- checkArgument(hierarchy.vertexSet().contains(id),
- "Unknown reader: %s. Known readers: %s", id, hierarchy.vertexSet());
-
- return hierarchy.outgoingEdgesOf(id).stream()
- .map(hierarchy::getEdgeTarget)
- .collect(Collectors.toSet());
- }
-
- Set<InstanceIdentifier<?>> getRoots() {
- return hierarchy.vertexSet().stream()
- .filter(vertex -> hierarchy.incomingEdgesOf(vertex).size() == 0)
- .collect(Collectors.toSet());
- }
-
- /**
- * Create reader hierarchy from a flat set of instance identifiers.
- *
- * @param allIds Set of unkeyed instance identifiers
- */
- static TypeHierarchy create(@Nonnull Set<InstanceIdentifier<?>> allIds) {
- final DirectedAcyclicGraph<InstanceIdentifier<?>, Parent>
- readersHierarchy = new DirectedAcyclicGraph<>((sourceVertex, targetVertex) -> new Parent());
-
- for (InstanceIdentifier<?> allId : allIds) {
- checkArgument(!Iterables.isEmpty(allId.getPathArguments()), "Empty ID detected");
-
- if (Iterables.size(allId.getPathArguments()) == 1) {
- readersHierarchy.addVertex(allId);
- }
-
- List<InstanceIdentifier.PathArgument> pathArgs = new LinkedList<>();
- pathArgs.add(allId.getPathArguments().iterator().next());
-
- for (InstanceIdentifier.PathArgument pathArgument : Iterables.skip(allId.getPathArguments(), 1)) {
- final InstanceIdentifier<?> previous = InstanceIdentifier.create(pathArgs);
- pathArgs.add(pathArgument);
- final InstanceIdentifier<?> current = InstanceIdentifier.create(pathArgs);
-
- readersHierarchy.addVertex(previous);
- readersHierarchy.addVertex(current);
-
- try {
- readersHierarchy.addDagEdge(previous, current);
- } catch (DirectedAcyclicGraph.CycleFoundException e) {
- throw new IllegalArgumentException("Loop in hierarchy detected", e);
- }
- }
- }
-
- return new TypeHierarchy(readersHierarchy);
- }
-
- private static final class Parent{}
-}
diff --git a/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/write/registry/FlatWriterRegistry.java b/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/write/registry/FlatWriterRegistry.java
deleted file mode 100644
index e5b829d6a..000000000
--- a/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/write/registry/FlatWriterRegistry.java
+++ /dev/null
@@ -1,314 +0,0 @@
-/*
- * 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.translate.util.write.registry;
-
-import static com.google.common.base.Preconditions.checkArgument;
-import static com.google.common.base.Preconditions.checkNotNull;
-import static io.fd.honeycomb.translate.util.RWUtils.makeIidWildcarded;
-
-import com.google.common.base.Optional;
-import com.google.common.collect.HashMultimap;
-import com.google.common.collect.ImmutableMap;
-import com.google.common.collect.ImmutableSet;
-import com.google.common.collect.Lists;
-import com.google.common.collect.Multimap;
-import com.google.common.collect.Sets;
-import io.fd.honeycomb.translate.TranslationException;
-import io.fd.honeycomb.translate.util.RWUtils;
-import io.fd.honeycomb.translate.write.DataObjectUpdate;
-import io.fd.honeycomb.translate.write.WriteContext;
-import io.fd.honeycomb.translate.write.WriteFailedException;
-import io.fd.honeycomb.translate.write.Writer;
-import io.fd.honeycomb.translate.write.registry.WriterRegistry;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.HashSet;
-import java.util.Map;
-import java.util.Set;
-import java.util.stream.Collectors;
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
-import javax.annotation.concurrent.ThreadSafe;
-import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-/**
- * Flat writer registry, delegating updates to writers in the order writers were submitted.
- */
-@ThreadSafe
-final class FlatWriterRegistry implements WriterRegistry {
-
- private static final Logger LOG = LoggerFactory.getLogger(FlatWriterRegistry.class);
-
- // All types handled by writers directly or as children
- private final ImmutableSet<InstanceIdentifier<?>> handledTypes;
-
- private final Set<InstanceIdentifier<?>> writersOrderReversed;
- private final Set<InstanceIdentifier<?>> writersOrder;
- private final Map<InstanceIdentifier<?>, Writer<?>> writers;
-
- /**
- * Create flat registry instance.
- *
- * @param writers immutable, ordered map of writers to use to process updates. Order of the writers has to be
- * one in which create and update operations should be handled. Deletes will be handled in reversed
- * order. All deletes are handled before handling all the updates.
- */
- FlatWriterRegistry(@Nonnull final ImmutableMap<InstanceIdentifier<?>, Writer<?>> writers) {
- this.writers = writers;
- this.writersOrderReversed = Sets.newLinkedHashSet(Lists.reverse(Lists.newArrayList(writers.keySet())));
- this.writersOrder = writers.keySet();
- this.handledTypes = getAllHandledTypes(writers);
- }
-
- private static ImmutableSet<InstanceIdentifier<?>> getAllHandledTypes(
- @Nonnull final ImmutableMap<InstanceIdentifier<?>, Writer<?>> writers) {
- final ImmutableSet.Builder<InstanceIdentifier<?>> handledTypesBuilder = ImmutableSet.builder();
- for (Map.Entry<InstanceIdentifier<?>, Writer<?>> writerEntry : writers.entrySet()) {
- final InstanceIdentifier<?> writerType = writerEntry.getKey();
- final Writer<?> writer = writerEntry.getValue();
- handledTypesBuilder.add(writerType);
- if (writer instanceof SubtreeWriter) {
- handledTypesBuilder.addAll(((SubtreeWriter<?>) writer).getHandledChildTypes());
- }
- }
- return handledTypesBuilder.build();
- }
-
- @Override
- public void update(@Nonnull final DataObjectUpdates updates,
- @Nonnull final WriteContext ctx) throws TranslationException {
- if (updates.isEmpty()) {
- return;
- }
-
- // Optimization
- if (updates.containsOnlySingleType()) {
- // First process delete
- singleUpdate(updates.getDeletes(), ctx);
- // Next is update
- singleUpdate(updates.getUpdates(), ctx);
- } else {
- // First process deletes
- bulkUpdate(updates.getDeletes(), ctx, true, writersOrderReversed);
- // Next are updates
- bulkUpdate(updates.getUpdates(), ctx, true, writersOrder);
- }
-
- LOG.debug("Update successful for types: {}", updates.getTypeIntersection());
- LOG.trace("Update successful for: {}", updates);
- }
-
- private void singleUpdate(@Nonnull final Multimap<InstanceIdentifier<?>, ? extends DataObjectUpdate> updates,
- @Nonnull final WriteContext ctx) throws WriteFailedException {
- if (updates.isEmpty()) {
- return;
- }
-
- final InstanceIdentifier<?> singleType = updates.keySet().iterator().next();
- LOG.debug("Performing single type update for: {}", singleType);
- Collection<? extends DataObjectUpdate> singleTypeUpdates = updates.get(singleType);
- Writer<?> writer = getWriter(singleType);
-
- if (writer == null) {
- // This node must be handled by a subtree writer, find it and call it or else fail
- checkArgument(handledTypes.contains(singleType), "Unable to process update. Missing writers for: %s",
- singleType);
- writer = getSubtreeWriterResponsible(singleType);
- singleTypeUpdates = getParentDataObjectUpdate(ctx, updates, writer);
- }
-
- LOG.trace("Performing single type update with writer: {}", writer);
- for (DataObjectUpdate singleUpdate : singleTypeUpdates) {
- writer.update(singleUpdate.getId(), singleUpdate.getDataBefore(), singleUpdate.getDataAfter(), ctx);
- }
- }
-
- private Writer<?> getSubtreeWriterResponsible(final InstanceIdentifier<?> singleType) {
- return writers.values().stream()
- .filter(w -> w instanceof SubtreeWriter)
- .filter(w -> ((SubtreeWriter<?>) w).getHandledChildTypes().contains(singleType))
- .findFirst()
- .get();
- }
-
- private Collection<DataObjectUpdate> getParentDataObjectUpdate(final WriteContext ctx,
- final Multimap<InstanceIdentifier<?>, ? extends DataObjectUpdate> updates,
- final Writer<?> writer) {
- // Now read data for subtree reader root, but first keyed ID is needed and that ID can be cut from updates
- InstanceIdentifier<?> firstAffectedChildId = ((SubtreeWriter<?>) writer).getHandledChildTypes().stream()
- .filter(updates::containsKey)
- .map(unkeyedId -> updates.get(unkeyedId))
- .flatMap(doUpdates -> doUpdates.stream())
- .map(DataObjectUpdate::getId)
- .findFirst()
- .get();
-
- final InstanceIdentifier<?> parentKeyedId =
- RWUtils.cutId(firstAffectedChildId, writer.getManagedDataObjectType());
-
- final Optional<? extends DataObject> parentBefore = ctx.readBefore(parentKeyedId);
- final Optional<? extends DataObject> parentAfter = ctx.readAfter(parentKeyedId);
- return Collections.singleton(
- DataObjectUpdate.create(parentKeyedId, parentBefore.orNull(), parentAfter.orNull()));
- }
-
- private void bulkUpdate(@Nonnull final Multimap<InstanceIdentifier<?>, ? extends DataObjectUpdate> updates,
- @Nonnull final WriteContext ctx,
- final boolean attemptRevert,
- @Nonnull final Set<InstanceIdentifier<?>> writersOrder) throws BulkUpdateException {
- if (updates.isEmpty()) {
- return;
- }
-
- LOG.debug("Performing bulk update with revert attempt: {} for: {}", attemptRevert, updates.keySet());
-
- // Check that all updates can be handled
- checkAllTypesCanBeHandled(updates);
-
- // Capture all changes successfully processed in case revert is needed
- final Set<InstanceIdentifier<?>> processedNodes = new HashSet<>();
-
- // Iterate over all writers and call update if there are any related updates
- for (InstanceIdentifier<?> writerType : writersOrder) {
- Collection<? extends DataObjectUpdate> writersData = updates.get(writerType);
- final Writer<?> writer = getWriter(writerType);
-
- if (writersData.isEmpty()) {
- // If there are no data for current writer, but it is a SubtreeWriter and there are updates to
- // its children, still invoke it with its root data
- if (writer instanceof SubtreeWriter<?> && isAffected(((SubtreeWriter<?>) writer), updates)) {
- // Provide parent data for SubtreeWriter for further processing
- writersData = getParentDataObjectUpdate(ctx, updates, writer);
- } else {
- // Skipping unaffected writer
- // Alternative to this would be modification sort according to the order of writers
- continue;
- }
- }
-
- LOG.debug("Performing update for: {}", writerType);
- LOG.trace("Performing update with writer: {}", writer);
-
- for (DataObjectUpdate singleUpdate : writersData) {
- try {
- writer.update(singleUpdate.getId(), singleUpdate.getDataBefore(), singleUpdate.getDataAfter(), ctx);
- processedNodes.add(singleUpdate.getId());
- LOG.trace("Update successful for type: {}", writerType);
- LOG.debug("Update successful for: {}", singleUpdate);
- } catch (Exception e) {
- // do not log this exception here,its logged in ModifiableDataTreeDelegator
-
- final Reverter reverter = attemptRevert
- ? new ReverterImpl(processedNodes, updates, writersOrder)
- : (final WriteContext writeContext) -> {};//NOOP reverter
-
- // Find out which changes left unprocessed
- final Set<InstanceIdentifier<?>> unprocessedChanges = updates.values().stream()
- .map(DataObjectUpdate::getId)
- .filter(id -> !processedNodes.contains(id))
- .collect(Collectors.toSet());
- throw new BulkUpdateException(unprocessedChanges, reverter, e);
- }
- }
- }
- }
-
- private void checkAllTypesCanBeHandled(
- @Nonnull final Multimap<InstanceIdentifier<?>, ? extends DataObjectUpdate> updates) {
- if (!handledTypes.containsAll(updates.keySet())) {
- final Sets.SetView<InstanceIdentifier<?>> missingWriters = Sets.difference(updates.keySet(), handledTypes);
- LOG.warn("Unable to process update. Missing writers for: {}", missingWriters);
- throw new IllegalArgumentException("Unable to process update. Missing writers for: " + missingWriters);
- }
- }
-
- /**
- * Check whether {@link SubtreeWriter} is affected by the updates.
- *
- * @return true if there are any updates to SubtreeWriter's child nodes (those marked by SubtreeWriter
- * as being taken care of)
- * */
- private static boolean isAffected(final SubtreeWriter<?> writer,
- final Multimap<InstanceIdentifier<?>, ? extends DataObjectUpdate> updates) {
- return !Sets.intersection(writer.getHandledChildTypes(), updates.keySet()).isEmpty();
- }
-
- @Nullable
- private Writer<?> getWriter(@Nonnull final InstanceIdentifier<?> singleType) {
- return writers.get(singleType);
- }
-
- private final class ReverterImpl implements Reverter {
-
- private final Collection<InstanceIdentifier<?>> processedNodes;
- private final Multimap<InstanceIdentifier<?>, ? extends DataObjectUpdate> updates;
- private final Set<InstanceIdentifier<?>> revertDeleteOrder;
-
- ReverterImpl(final Collection<InstanceIdentifier<?>> processedNodes,
- final Multimap<InstanceIdentifier<?>, ? extends DataObjectUpdate> updates,
- final Set<InstanceIdentifier<?>> writersOrderOriginal) {
- this.processedNodes = processedNodes;
- this.updates = updates;
- // Use opposite ordering when executing revert
- this.revertDeleteOrder = writersOrderOriginal == FlatWriterRegistry.this.writersOrder
- ? FlatWriterRegistry.this.writersOrderReversed
- : FlatWriterRegistry.this.writersOrder;
- }
-
- @Override
- public void revert(@Nonnull final WriteContext writeContext) throws RevertFailedException {
- checkNotNull(writeContext, "Cannot revert changes for null context");
-
- Multimap<InstanceIdentifier<?>, DataObjectUpdate> updatesToRevert =
- filterAndRevertProcessed(updates, processedNodes);
-
- LOG.info("Attempting revert for changes: {}", updatesToRevert);
- try {
- // Perform reversed bulk update without revert attempt
- bulkUpdate(updatesToRevert, writeContext, true, revertDeleteOrder);
- LOG.info("Revert successful");
- } catch (BulkUpdateException e) {
- LOG.error("Revert failed", e);
- throw new RevertFailedException(e.getFailedIds(), e);
- }
- }
-
- /**
- * Create new updates map, but only keep already processed changes. Switching before and after data for each
- * update.
- */
- private Multimap<InstanceIdentifier<?>, DataObjectUpdate> filterAndRevertProcessed(
- final Multimap<InstanceIdentifier<?>, ? extends DataObjectUpdate> updates,
- final Collection<InstanceIdentifier<?>> processedNodes) {
- final Multimap<InstanceIdentifier<?>, DataObjectUpdate> filtered = HashMultimap.create();
- for (InstanceIdentifier<?> processedNode : processedNodes) {
- final InstanceIdentifier<?> wildcardedIid = makeIidWildcarded(processedNode);
- if (updates.containsKey(wildcardedIid)) {
- updates.get(wildcardedIid).stream()
- .filter(dataObjectUpdate -> processedNode.contains(dataObjectUpdate.getId()))
- // putting under unkeyed identifier, to prevent failing of checkAllTypesCanBeHandled
- .forEach(dataObjectUpdate -> filtered.put(wildcardedIid, dataObjectUpdate.reverse()));
- }
- }
- return filtered;
- }
- }
-
-}
diff --git a/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/write/registry/FlatWriterRegistryBuilder.java b/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/write/registry/FlatWriterRegistryBuilder.java
deleted file mode 100644
index 0f75de7e7..000000000
--- a/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/write/registry/FlatWriterRegistryBuilder.java
+++ /dev/null
@@ -1,71 +0,0 @@
-/*
- * 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.translate.util.write.registry;
-
-import com.google.common.annotations.VisibleForTesting;
-import com.google.common.collect.ImmutableMap;
-import io.fd.honeycomb.translate.write.registry.WriterRegistryBuilder;
-import io.fd.honeycomb.translate.util.AbstractSubtreeManagerRegistryBuilderBuilder;
-import io.fd.honeycomb.translate.write.Writer;
-import io.fd.honeycomb.translate.write.registry.ModifiableWriterRegistryBuilder;
-import io.fd.honeycomb.translate.write.registry.WriterRegistry;
-import java.util.Set;
-import java.util.stream.Collectors;
-import javax.annotation.Nonnull;
-import javax.annotation.concurrent.NotThreadSafe;
-import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-/**
- * Builder for {@link FlatWriterRegistry} allowing users to specify inter-writer relationships.
- */
-@NotThreadSafe
-public final class FlatWriterRegistryBuilder
- extends AbstractSubtreeManagerRegistryBuilderBuilder<Writer<? extends DataObject>, WriterRegistry>
- implements ModifiableWriterRegistryBuilder, WriterRegistryBuilder {
-
- private static final Logger LOG = LoggerFactory.getLogger(FlatWriterRegistryBuilder.class);
-
- @Override
- protected Writer<? extends DataObject> getSubtreeHandler(final @Nonnull Set<InstanceIdentifier<?>> handledChildren,
- final @Nonnull Writer<? extends DataObject> writer) {
- return SubtreeWriter.createForWriter(handledChildren, writer);
- }
-
- /**
- * Create FlatWriterRegistry with writers ordered according to submitted relationships.
- */
- @Override
- public WriterRegistry build() {
- final ImmutableMap<InstanceIdentifier<?>, Writer<?>> mappedWriters = getMappedHandlers();
- LOG.debug("Building writer registry with writers: {}",
- mappedWriters.keySet().stream()
- .map(InstanceIdentifier::getTargetType)
- .map(Class::getSimpleName)
- .collect(Collectors.joining(", ")));
- LOG.trace("Building writer registry with writers: {}", mappedWriters);
- return new FlatWriterRegistry(mappedWriters);
- }
-
- @VisibleForTesting
- @Override
- protected ImmutableMap<InstanceIdentifier<?>, Writer<? extends DataObject>> getMappedHandlers() {
- return super.getMappedHandlers();
- }
-}
diff --git a/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/write/registry/SubtreeWriter.java b/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/write/registry/SubtreeWriter.java
deleted file mode 100644
index bab1da16f..000000000
--- a/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/write/registry/SubtreeWriter.java
+++ /dev/null
@@ -1,85 +0,0 @@
-/*
- * 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.translate.util.write.registry;
-
-import static com.google.common.base.Preconditions.checkArgument;
-
-import com.google.common.collect.Iterables;
-import io.fd.honeycomb.translate.write.WriteContext;
-import io.fd.honeycomb.translate.write.WriteFailedException;
-import io.fd.honeycomb.translate.write.Writer;
-import java.util.HashSet;
-import java.util.Set;
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
-import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-
-/**
- * Simple writer delegate for subtree writers (writers handling also children nodes) providing a list of all the
- * children nodes being handled.
- */
-final class SubtreeWriter<D extends DataObject> implements Writer<D> {
-
- private final Writer<D> delegate;
- private final Set<InstanceIdentifier<?>> handledChildTypes = new HashSet<>();
-
- private SubtreeWriter(final Writer<D> delegate, Set<InstanceIdentifier<?>> handledTypes) {
- this.delegate = delegate;
- for (InstanceIdentifier<?> handledType : handledTypes) {
- // Iid has to start with writer's handled root type
- checkArgument(delegate.getManagedDataObjectType().getTargetType().equals(
- handledType.getPathArguments().iterator().next().getType()),
- "Handled node from subtree has to be identified by an instance identifier starting from: %s."
- + "Instance identifier was: %s", getManagedDataObjectType().getTargetType(), handledType);
- checkArgument(Iterables.size(handledType.getPathArguments()) > 1,
- "Handled node from subtree identifier too short: %s", handledType);
- handledChildTypes.add(InstanceIdentifier.create(Iterables.concat(
- getManagedDataObjectType().getPathArguments(), Iterables.skip(handledType.getPathArguments(), 1))));
- }
- }
-
- /**
- * Return set of types also handled by this writer. All of the types are children of the type managed by this
- * writer excluding the type of this writer.
- */
- Set<InstanceIdentifier<?>> getHandledChildTypes() {
- return handledChildTypes;
- }
-
- @Override
- public void update(
- @Nonnull final InstanceIdentifier<? extends DataObject> id,
- @Nullable final DataObject dataBefore,
- @Nullable final DataObject dataAfter, @Nonnull final WriteContext ctx) throws WriteFailedException {
- delegate.update(id, dataBefore, dataAfter, ctx);
- }
-
- @Override
- @Nonnull
- public InstanceIdentifier<D> getManagedDataObjectType() {
- return delegate.getManagedDataObjectType();
- }
-
- /**
- * Wrap a writer as a subtree writer.
- */
- static Writer<?> createForWriter(@Nonnull final Set<InstanceIdentifier<?>> handledChildren,
- @Nonnull final Writer<? extends DataObject> writer) {
- return new SubtreeWriter<>(writer, handledChildren);
- }
-}
diff --git a/infra/translate-utils/src/test/java/io/fd/honeycomb/translate/util/read/registry/CompositeReaderRegistryBuilderTest.java b/infra/translate-utils/src/test/java/io/fd/honeycomb/translate/util/read/registry/CompositeReaderRegistryBuilderTest.java
deleted file mode 100644
index d742575be..000000000
--- a/infra/translate-utils/src/test/java/io/fd/honeycomb/translate/util/read/registry/CompositeReaderRegistryBuilderTest.java
+++ /dev/null
@@ -1,114 +0,0 @@
-/*
- * 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.translate.util.read.registry;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
-import static org.mockito.Mockito.when;
-
-import com.google.common.collect.ImmutableMap;
-import com.google.common.collect.Lists;
-import io.fd.honeycomb.translate.read.Reader;
-import io.fd.honeycomb.translate.read.registry.ReaderRegistry;
-import io.fd.honeycomb.translate.util.DataObjects;
-import java.util.List;
-import java.util.Map;
-import org.junit.Test;
-import org.mockito.Mockito;
-import org.opendaylight.yangtools.concepts.Builder;
-import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-
-public class CompositeReaderRegistryBuilderTest {
-
- private Reader<DataObjects.DataObject1, Builder<DataObjects.DataObject1>> reader1 =
- mock(DataObjects.DataObject1.class);
- private Reader<DataObjects.DataObject2, Builder<DataObjects.DataObject2>> reader2 =
- mock(DataObjects.DataObject2.class);
- private Reader<DataObjects.DataObject3, Builder<DataObjects.DataObject3>> reader3 =
- mock(DataObjects.DataObject3.class);
- private Reader<DataObjects.DataObject3.DataObject31, Builder<DataObjects.DataObject3.DataObject31>> reader31 =
- mock(DataObjects.DataObject3.DataObject31.class);
-
- private Reader<DataObjects.DataObject4, Builder<DataObjects.DataObject4>> reader4 =
- mock(DataObjects.DataObject4.class);
- private Reader<DataObjects.DataObject4.DataObject41, Builder<DataObjects.DataObject4.DataObject41>> reader41 =
- mock(DataObjects.DataObject4.DataObject41.class);
- private Reader<DataObjects.DataObject4.DataObject41.DataObject411, Builder<DataObjects.DataObject4.DataObject41.DataObject411>> reader411 =
- mock(DataObjects.DataObject4.DataObject41.DataObject411.class);
- private Reader<DataObjects.DataObject4.DataObject42, Builder<DataObjects.DataObject4.DataObject42>> reader42 =
- mock(DataObjects.DataObject4.DataObject42.class);
-
- @SuppressWarnings("unchecked")
- private <D extends DataObject> Reader<D, Builder<D>> mock(final Class<D> dataObjectType) {
- final Reader<D, Builder<D>> mock = Mockito.mock(Reader.class);
- try {
- when(mock.getManagedDataObjectType())
- .thenReturn(((InstanceIdentifier<D>) dataObjectType.getDeclaredField("IID").get(null)));
- } catch (IllegalAccessException | NoSuchFieldException e) {
- throw new RuntimeException(e);
- }
- return mock;
- }
-
- @Test
- public void testCompositeStructure() throws Exception {
- final CompositeReaderRegistryBuilder compositeReaderRegistryBuilder = new CompositeReaderRegistryBuilder();
- /*
- Composite reader structure ordered left from right
-
- 1, 2, 3, 4
- 31 42, 41
- 411
- */
- compositeReaderRegistryBuilder.add(reader1);
- compositeReaderRegistryBuilder.addAfter(reader2, reader1.getManagedDataObjectType());
- compositeReaderRegistryBuilder.addAfter(reader3, reader2.getManagedDataObjectType());
- compositeReaderRegistryBuilder.addAfter(reader31, reader1.getManagedDataObjectType());
- compositeReaderRegistryBuilder.addAfter(reader4, reader3.getManagedDataObjectType());
- compositeReaderRegistryBuilder.add(reader41);
- compositeReaderRegistryBuilder.addBefore(reader42, reader41.getManagedDataObjectType());
- compositeReaderRegistryBuilder.add(reader411);
-
- final ReaderRegistry build = compositeReaderRegistryBuilder.build();
-
- final Map<Class<? extends DataObject>, Reader<? extends DataObject, ? extends Builder<?>>> rootReaders =
- ((CompositeReaderRegistry) build).getRootReaders();
- final List<Class<? extends DataObject>> rootReaderOrder = Lists.newArrayList(rootReaders.keySet());
-
- assertEquals(reader1.getManagedDataObjectType().getTargetType(), rootReaderOrder.get(0));
- assertEquals(reader2.getManagedDataObjectType().getTargetType(), rootReaderOrder.get(1));
- assertEquals(reader3.getManagedDataObjectType().getTargetType(), rootReaderOrder.get(2));
- assertEquals(reader4.getManagedDataObjectType().getTargetType(), rootReaderOrder.get(3));
-
- assertFalse(rootReaders.get(DataObjects.DataObject1.class) instanceof CompositeReader);
- assertFalse(rootReaders.get(DataObjects.DataObject2.class) instanceof CompositeReader);
- assertTrue(rootReaders.get(DataObjects.DataObject3.class) instanceof CompositeReader);
- assertTrue(rootReaders.get(DataObjects.DataObject4.class) instanceof CompositeReader);
-
- final ImmutableMap<Class<?>, Reader<? extends DataObject, ? extends Builder<?>>> childReaders =
- ((CompositeReader<? extends DataObject, ? extends Builder<?>>) rootReaders
- .get(DataObjects.DataObject4.class)).getChildReaders();
- final List<Class<?>> orderedChildReaders = Lists.newArrayList(childReaders.keySet());
-
- assertEquals(reader42.getManagedDataObjectType().getTargetType(), orderedChildReaders.get(0));
- assertEquals(reader41.getManagedDataObjectType().getTargetType(), orderedChildReaders.get(1));
- assertTrue(childReaders.get(DataObjects.DataObject4.DataObject41.class) instanceof CompositeReader);
- assertFalse(childReaders.get(DataObjects.DataObject4.DataObject42.class) instanceof CompositeReader);
- }
-} \ No newline at end of file
diff --git a/infra/translate-utils/src/test/java/io/fd/honeycomb/translate/util/read/registry/CompositeReaderRegistryTest.java b/infra/translate-utils/src/test/java/io/fd/honeycomb/translate/util/read/registry/CompositeReaderRegistryTest.java
deleted file mode 100644
index 06cb8498f..000000000
--- a/infra/translate-utils/src/test/java/io/fd/honeycomb/translate/util/read/registry/CompositeReaderRegistryTest.java
+++ /dev/null
@@ -1,112 +0,0 @@
-/*
- * 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.translate.util.read.registry;
-
-import static io.fd.honeycomb.translate.util.DataObjects.DataObject3;
-import static io.fd.honeycomb.translate.util.DataObjects.DataObject3.DataObject31;
-import static io.fd.honeycomb.translate.util.DataObjects.DataObject4;
-import static io.fd.honeycomb.translate.util.DataObjects.DataObject4.DataObject41;
-import static org.mockito.Matchers.any;
-import static org.mockito.Mockito.inOrder;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.spy;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
-
-import com.google.common.base.Optional;
-import com.google.common.collect.ImmutableMap;
-import com.google.common.collect.Lists;
-import io.fd.honeycomb.translate.read.ReadContext;
-import io.fd.honeycomb.translate.read.Reader;
-import org.junit.Before;
-import org.junit.Test;
-import org.mockito.InOrder;
-import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
-import org.opendaylight.yangtools.concepts.Builder;
-import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-
-public class CompositeReaderRegistryTest {
-
- @Mock
- private ReadContext ctx;
- private CompositeReaderRegistry reg;
- private Reader<DataObject31, Builder<DataObject31>> reader31;
- private Reader<DataObject3, Builder<DataObject3>> rootReader3;
- private Reader<DataObject41, Builder<DataObject41>> reader41;
- private Reader<DataObject4, Builder<DataObject4>> rootReader4;
-
- @Before
- public void setUp() throws Exception {
- MockitoAnnotations.initMocks(this);
-
- reader31 = mockReader(DataObject31.class);
- rootReader3 =
- spy(CompositeReader.createForReader(
- mockReader(DataObject3.class),
- ImmutableMap.of(DataObject31.class, reader31)));
-
- reader41 = mockReader(DataObject41.class);
- rootReader4 =
- spy(CompositeReader.createForReader(
- mockReader(DataObject4.class), ImmutableMap.of(
- DataObject41.class, reader41)));
-
- reg = new CompositeReaderRegistry(Lists.newArrayList(rootReader3, rootReader4));
- }
-
- @Test
- public void testReadAll() throws Exception {
- reg.readAll(ctx);
-
- // Invoked according to composite ordering
- final InOrder inOrder = inOrder(rootReader3, rootReader4, reader31, reader41);
- inOrder.verify(rootReader3).read(any(InstanceIdentifier.class), any(ReadContext.class));
- inOrder.verify(reader31).read(any(InstanceIdentifier.class), any(ReadContext.class));
- inOrder.verify(rootReader4).read(any(InstanceIdentifier.class), any(ReadContext.class));
- inOrder.verify(reader41).read(any(InstanceIdentifier.class), any(ReadContext.class));
- }
-
- @Test
- public void testReadSingleRoot() throws Exception {
- reg.read(DataObject3.IID, ctx);
-
- // Invoked according to composite ordering
- final InOrder inOrder = inOrder(rootReader3, rootReader4, reader31, reader41);
- inOrder.verify(rootReader3).read(any(InstanceIdentifier.class), any(ReadContext.class));
- inOrder.verify(reader31).read(any(InstanceIdentifier.class), any(ReadContext.class));
-
- // Only subtree under DataObject3 should be read
- verify(rootReader4, times(0)).read(any(InstanceIdentifier.class), any(ReadContext.class));
- verify(reader41, times(0)).read(any(InstanceIdentifier.class), any(ReadContext.class));
- }
-
- @SuppressWarnings("unchecked")
- static <D extends DataObject, B extends Builder<D>> Reader<D, B> mockReader(final Class<D> dataType)
- throws Exception {
- final Reader r = mock(Reader.class);
- final Object iid = dataType.getDeclaredField("IID").get(null);
- when(r.getManagedDataObjectType()).thenReturn((InstanceIdentifier) iid);
- final Builder builder = mock(Builder.class);
- when(builder.build()).thenReturn(mock(dataType));
- when(r.getBuilder(any(InstanceIdentifier.class))).thenReturn(builder);
- when(r.read(any(InstanceIdentifier.class), any(ReadContext.class))).thenReturn(Optional.of(mock(dataType)));
- return (Reader<D, B>) r;
- }
-} \ No newline at end of file
diff --git a/infra/translate-utils/src/test/java/io/fd/honeycomb/translate/util/read/registry/CompositeReaderTest.java b/infra/translate-utils/src/test/java/io/fd/honeycomb/translate/util/read/registry/CompositeReaderTest.java
deleted file mode 100644
index 9ae036013..000000000
--- a/infra/translate-utils/src/test/java/io/fd/honeycomb/translate/util/read/registry/CompositeReaderTest.java
+++ /dev/null
@@ -1,124 +0,0 @@
-/*
- * 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.translate.util.read.registry;
-
-import static io.fd.honeycomb.translate.util.DataObjects.DataObject4;
-import static io.fd.honeycomb.translate.util.DataObjects.DataObject4.DataObject41;
-import static io.fd.honeycomb.translate.util.DataObjects.DataObjectK;
-import static io.fd.honeycomb.translate.util.DataObjects.DataObjectKey;
-import static io.fd.honeycomb.translate.util.read.registry.CompositeReaderRegistryTest.mockReader;
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.eq;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
-
-import com.google.common.base.Optional;
-import com.google.common.collect.ImmutableMap;
-import com.google.common.collect.Lists;
-import io.fd.honeycomb.translate.read.ListReader;
-import io.fd.honeycomb.translate.read.ReadContext;
-import io.fd.honeycomb.translate.read.Reader;
-import io.fd.honeycomb.translate.util.DataObjects;
-import java.util.List;
-import org.junit.Before;
-import org.junit.Test;
-import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
-import org.opendaylight.yangtools.concepts.Builder;
-import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.Identifiable;
-import org.opendaylight.yangtools.yang.binding.Identifier;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-
-public class CompositeReaderTest {
-
- @Mock
- private ReadContext ctx;
- private Reader<DataObject41, Builder<DataObject41>> reader41;
- private Reader<DataObject4, Builder<DataObject4>> reader4;
- private Reader<DataObject4, Builder<DataObject4>> compositeReader;
-
- @Before
- public void setUp() throws Exception {
- MockitoAnnotations.initMocks(this);
-
- reader41 = mockReader(DataObject41.class);
- reader4 = mockReader(DataObject4.class);
- compositeReader = CompositeReader
- .createForReader(reader4, ImmutableMap.of(DataObject41.class, reader41));
- }
-
- @Test
- public void testReadCurrent() throws Exception {
- compositeReader.read(DataObject4.IID, ctx);
- verify(reader4).readCurrentAttributes(eq(DataObject4.IID), any(Builder.class), eq(ctx));
- verify(reader41).read(DataObject41.IID, ctx);
- }
-
- @Test
- public void testReadJustChild() throws Exception {
- // Delegating read to child
- compositeReader.read(DataObject41.IID, ctx);
- verify(reader4, times(0))
- .readCurrentAttributes(any(InstanceIdentifier.class), any(Builder.class), any(ReadContext.class));
- verify(reader41).read(DataObject41.IID, ctx);
- }
-
- @Test
- public void testReadFallback() throws Exception {
- // Delegating read to delegate as a fallback since IID does not fit, could be handled by the delegate if its
- // a subtree handler
- compositeReader.read(DataObjects.DataObject4.DataObject42.IID, ctx);
- verify(reader4).read(DataObjects.DataObject4.DataObject42.IID, ctx);
- verify(reader41, times(0)).read(any(InstanceIdentifier.class), any(ReadContext.class));
- }
-
- @Test
- public void testList() throws Exception {
- final Reader<DataObjectK.DataObjectK1, Builder<DataObjectK.DataObjectK1>> readerK1 =
- mockReader(DataObjectK.DataObjectK1.class);
- final ListReader<DataObjectK, DataObjectKey, Builder<DataObjectK>> readerK =
- mockListReader(DataObjectK.class, Lists.newArrayList(new DataObjectKey(), new DataObjectKey()));
- final ListReader<DataObjectK, DataObjectKey, Builder<DataObjectK>>
- compositeReaderK = (ListReader<DataObjectK, DataObjectKey, Builder<DataObjectK>>)
- CompositeReader.createForReader(readerK, ImmutableMap.of(DataObject41.class, readerK1));
-
- compositeReaderK.readList(DataObjectK.IID, ctx);
-
- verify(readerK).getAllIds(DataObjectK.IID, ctx);
- verify(readerK, times(2))
- .readCurrentAttributes(any(InstanceIdentifier.class), any(Builder.class), any(ReadContext.class));
- }
-
- @SuppressWarnings("unchecked")
- static <D extends DataObject & Identifiable<K>, K extends Identifier<D>, B extends Builder<D>> ListReader<D, K, B> mockListReader(
- final Class<D> dataType, List<K> keys)
- throws Exception {
- final ListReader r = mock(ListReader.class);
- final Object iid = dataType.getDeclaredField("IID").get(null);
- when(r.getManagedDataObjectType()).thenReturn((InstanceIdentifier) iid);
- final Builder builder = mock(Builder.class);
- when(builder.build()).thenReturn(mock(dataType));
- when(r.getBuilder(any(InstanceIdentifier.class))).thenReturn(builder);
- when(r.read(any(InstanceIdentifier.class), any(ReadContext.class))).thenReturn(Optional.of(mock(dataType)));
- when(r.getAllIds(any(InstanceIdentifier.class), any(ReadContext.class))).thenReturn(keys);
- return (ListReader<D, K, B>) r;
- }
-
-} \ No newline at end of file
diff --git a/infra/translate-utils/src/test/java/io/fd/honeycomb/translate/util/read/registry/SubtreeReaderTest.java b/infra/translate-utils/src/test/java/io/fd/honeycomb/translate/util/read/registry/SubtreeReaderTest.java
deleted file mode 100644
index 799b9553f..000000000
--- a/infra/translate-utils/src/test/java/io/fd/honeycomb/translate/util/read/registry/SubtreeReaderTest.java
+++ /dev/null
@@ -1,124 +0,0 @@
-/*
- * 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.translate.util.read.registry;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.mockito.Mockito.atLeastOnce;
-import static org.mockito.Mockito.doReturn;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.verify;
-
-import com.google.common.base.Optional;
-import com.google.common.collect.Sets;
-import io.fd.honeycomb.translate.read.ReadContext;
-import io.fd.honeycomb.translate.read.Reader;
-import io.fd.honeycomb.translate.util.DataObjects;
-import org.junit.Before;
-import org.junit.Test;
-import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
-import org.opendaylight.yangtools.concepts.Builder;
-import org.opendaylight.yangtools.yang.binding.ChildOf;
-import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-
-public class SubtreeReaderTest {
-
- @Mock
- private Reader<DataObjects.DataObject4, Builder<DataObjects.DataObject4>> delegate;
- @Mock
- private Reader<DataObject1, Builder<DataObject1>> delegateLocal;
- @Mock
- private ReadContext ctx;
-
- @Before
- public void setUp() throws Exception {
- MockitoAnnotations.initMocks(this);
- doReturn(DataObjects.DataObject4.IID).when(delegate).getManagedDataObjectType();
- doReturn(DataObject1.IID).when(delegateLocal).getManagedDataObjectType();
- }
-
- @Test
- public void testCreate() throws Exception {
- final Reader<DataObjects.DataObject4, Builder<DataObjects.DataObject4>> subtreeR =
- SubtreeReader.createForReader(Sets.newHashSet(DataObjects.DataObject4.DataObject41.IID), delegate);
-
- subtreeR.getBuilder(DataObjects.DataObject4.IID);
- verify(delegate).getBuilder(DataObjects.DataObject4.IID);
-
- subtreeR.getManagedDataObjectType();
- verify(delegate, atLeastOnce()).getManagedDataObjectType();
- }
-
- @Test(expected = IllegalArgumentException.class)
- public void testCreateInvalid() throws Exception {
- SubtreeReader.createForReader(Sets.newHashSet(DataObjects.DataObject1.IID), delegate);
- }
-
- @Test(expected = IllegalStateException.class)
- public void testReadOnlySubtreeCannotFilter() throws Exception {
- final Reader<DataObjects.DataObject4, Builder<DataObjects.DataObject4>> subtreeR =
- SubtreeReader.createForReader(Sets.newHashSet(DataObjects.DataObject4.DataObject41.IID), delegate);
-
- doReturn(Optional.fromNullable(mock(DataObjects.DataObject4.class))).when(delegate).read(DataObjects.DataObject4.IID, ctx);
- subtreeR.read(DataObjects.DataObject4.DataObject41.IID, ctx);
- }
-
- @Test
- public void testReadOnlySubtreeNotPresent() throws Exception {
- final Reader<DataObjects.DataObject4, Builder<DataObjects.DataObject4>> subtreeR =
- SubtreeReader.createForReader(Sets.newHashSet(DataObjects.DataObject4.DataObject41.IID), delegate);
-
- doReturn(Optional.absent()).when(delegate).read(DataObjects.DataObject4.IID, ctx);
- assertFalse(subtreeR.read(DataObjects.DataObject4.DataObject41.IID, ctx).isPresent());
- }
-
- @Test
- public void testReadOnlySubtreeChild() throws Exception {
- final Reader<DataObject1, Builder<DataObject1>> subtreeR =
- SubtreeReader.createForReader(Sets.newHashSet(DataObject1.DataObject11.IID), delegateLocal);
-
- final DataObject1 mock = mock(DataObject1.class);
- final DataObject1.DataObject11 mock11 = mock(DataObject1.DataObject11.class);
- doReturn(mock11).when(mock).getDataObject11();
- doReturn(Optional.fromNullable(mock)).when(delegateLocal).read(DataObject1.IID, ctx);
- assertEquals(mock11, subtreeR.read(DataObject1.DataObject11.IID, ctx).get());
- }
-
- @Test
- public void testReadEntireSubtree() throws Exception {
- final Reader<DataObject1, Builder<DataObject1>> subtreeR =
- SubtreeReader.createForReader(Sets.newHashSet(DataObject1.DataObject11.IID), delegateLocal);
-
- final DataObject1 mock = mock(DataObject1.class);
- final DataObject1.DataObject11 mock11 = mock(DataObject1.DataObject11.class);
- doReturn(mock11).when(mock).getDataObject11();
- doReturn(Optional.fromNullable(mock)).when(delegateLocal).read(DataObject1.IID, ctx);
- assertEquals(mock, subtreeR.read(DataObject1.IID, ctx).get());
- }
-
- public abstract static class DataObject1 implements DataObject {
- public static InstanceIdentifier<DataObject1> IID = InstanceIdentifier.create(DataObject1.class);
-
- public abstract DataObject11 getDataObject11();
-
- public abstract static class DataObject11 implements DataObject, ChildOf<DataObject1> {
- public static InstanceIdentifier<DataObject11> IID = DataObject1.IID.child(DataObject11.class);
- }
- }
-}
diff --git a/infra/translate-utils/src/test/java/io/fd/honeycomb/translate/util/read/registry/TypeHierarchyTest.java b/infra/translate-utils/src/test/java/io/fd/honeycomb/translate/util/read/registry/TypeHierarchyTest.java
deleted file mode 100644
index 3b3ea3a35..000000000
--- a/infra/translate-utils/src/test/java/io/fd/honeycomb/translate/util/read/registry/TypeHierarchyTest.java
+++ /dev/null
@@ -1,72 +0,0 @@
-/*
- * 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.translate.util.read.registry;
-
-import static org.hamcrest.CoreMatchers.hasItem;
-import static org.hamcrest.CoreMatchers.hasItems;
-import static org.hamcrest.CoreMatchers.is;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertThat;
-import static org.junit.Assert.assertTrue;
-
-import com.google.common.collect.Sets;
-import io.fd.honeycomb.translate.util.DataObjects;
-import org.hamcrest.CoreMatchers;
-import org.junit.Test;
-
-public class TypeHierarchyTest {
-
- @Test
- public void testHierarchy() throws Exception {
- final TypeHierarchy typeHierarchy = TypeHierarchy.create(Sets.newHashSet(
- DataObjects.DataObject4.DataObject41.DataObject411.IID,
- DataObjects.DataObject4.DataObject41.IID,/* Included in previous already */
- DataObjects.DataObject1.IID,
- DataObjects.DataObject3.DataObject31.IID));
-
- // Roots
- assertThat(typeHierarchy.getRoots().size(), is(3));
- assertThat(typeHierarchy.getRoots(), CoreMatchers
- .hasItems(DataObjects.DataObject1.IID, DataObjects.DataObject3.IID, DataObjects.DataObject4.IID));
-
- // Leaves
- assertThat(typeHierarchy.getDirectChildren(DataObjects.DataObject1.IID).size(), is(0));
- assertThat(typeHierarchy.getDirectChildren(DataObjects.DataObject3.DataObject31.IID).size(), is(0));
- assertThat(typeHierarchy.getDirectChildren(DataObjects.DataObject4.DataObject41.DataObject411.IID).size(), is(0));
-
- // Intermediate leaves
- assertThat(typeHierarchy.getDirectChildren(DataObjects.DataObject3.IID).size(), is(1));
- assertThat(typeHierarchy.getDirectChildren(DataObjects.DataObject3.IID), CoreMatchers
- .hasItem(DataObjects.DataObject3.DataObject31.IID));
- assertEquals(typeHierarchy.getDirectChildren(DataObjects.DataObject3.IID), typeHierarchy.getAllChildren(
- DataObjects.DataObject3.IID));
-
- assertThat(typeHierarchy.getDirectChildren(DataObjects.DataObject4.DataObject41.IID).size(), is(1));
- assertThat(typeHierarchy.getDirectChildren(DataObjects.DataObject4.DataObject41.IID), CoreMatchers.hasItem(
- DataObjects.DataObject4.DataObject41.DataObject411.IID));
- assertEquals(typeHierarchy.getDirectChildren(DataObjects.DataObject4.DataObject41.IID), typeHierarchy.getAllChildren(
- DataObjects.DataObject4.DataObject41.IID));
-
- assertThat(typeHierarchy.getDirectChildren(DataObjects.DataObject4.IID).size(), is(1));
- assertThat(typeHierarchy.getDirectChildren(DataObjects.DataObject4.IID), CoreMatchers
- .hasItem(DataObjects.DataObject4.DataObject41.IID));
- assertThat(typeHierarchy.getAllChildren(DataObjects.DataObject4.IID).size(), is(2));
- assertTrue(typeHierarchy.getAllChildren(DataObjects.DataObject4.IID).contains(DataObjects.DataObject4.DataObject41.IID));
- assertTrue(typeHierarchy.getAllChildren(DataObjects.DataObject4.IID).contains(DataObjects.DataObject4.DataObject41.DataObject411.IID));
- }
-}
-
diff --git a/infra/translate-utils/src/test/java/io/fd/honeycomb/translate/util/write/registry/FlatWriterRegistryBuilderTest.java b/infra/translate-utils/src/test/java/io/fd/honeycomb/translate/util/write/registry/FlatWriterRegistryBuilderTest.java
deleted file mode 100644
index 7822c8926..000000000
--- a/infra/translate-utils/src/test/java/io/fd/honeycomb/translate/util/write/registry/FlatWriterRegistryBuilderTest.java
+++ /dev/null
@@ -1,193 +0,0 @@
-/*
- * 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.translate.util.write.registry;
-
-import static org.hamcrest.CoreMatchers.anyOf;
-import static org.hamcrest.CoreMatchers.equalTo;
-import static org.hamcrest.CoreMatchers.hasItems;
-import static org.hamcrest.CoreMatchers.instanceOf;
-import static org.hamcrest.CoreMatchers.is;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertThat;
-import static org.mockito.Mockito.doReturn;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
-
-import com.google.common.collect.ImmutableMap;
-import com.google.common.collect.Lists;
-import com.google.common.collect.Multimaps;
-import com.google.common.collect.Sets;
-import io.fd.honeycomb.translate.util.DataObjects;
-import io.fd.honeycomb.translate.write.DataObjectUpdate;
-import io.fd.honeycomb.translate.write.WriteContext;
-import io.fd.honeycomb.translate.write.Writer;
-import io.fd.honeycomb.translate.write.registry.WriterRegistry;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-import org.junit.Test;
-import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-
-public class FlatWriterRegistryBuilderTest {
-
- @Test
- public void testRelationsBefore() throws Exception {
- final FlatWriterRegistryBuilder flatWriterRegistryBuilder = new FlatWriterRegistryBuilder();
- /*
- 1 -> 2 -> 3
- -> 4
- */
- flatWriterRegistryBuilder.add(mockWriter(DataObjects.DataObject3.class));
- flatWriterRegistryBuilder.add(mockWriter(DataObjects.DataObject4.class));
- flatWriterRegistryBuilder.addBefore(mockWriter(DataObjects.DataObject2.class),
- Lists.newArrayList(DataObjects.DataObject3.IID, DataObjects.DataObject4.IID));
- flatWriterRegistryBuilder.addBefore(mockWriter(DataObjects.DataObject1.class), DataObjects.DataObject2.IID);
- final ImmutableMap<InstanceIdentifier<?>, Writer<?>> mappedWriters =
- flatWriterRegistryBuilder.getMappedHandlers();
-
- final ArrayList<InstanceIdentifier<?>> typesInList = Lists.newArrayList(mappedWriters.keySet());
- assertEquals(DataObjects.DataObject1.IID, typesInList.get(0));
- assertEquals(DataObjects.DataObject2.IID, typesInList.get(1));
- assertThat(typesInList.get(2), anyOf(equalTo(DataObjects.DataObject3.IID), equalTo(DataObjects.DataObject4.IID)));
- assertThat(typesInList.get(3), anyOf(equalTo(DataObjects.DataObject3.IID), equalTo(DataObjects.DataObject4.IID)));
- }
-
- @Test
- public void testBuild() throws Exception {
- final FlatWriterRegistryBuilder flatWriterRegistryBuilder = new FlatWriterRegistryBuilder();
- final Writer<? extends DataObject> writer = mockWriter(DataObjects.DataObject3.class);
- flatWriterRegistryBuilder.add(writer);
- final WriterRegistry build = flatWriterRegistryBuilder.build();
-
- final InstanceIdentifier<DataObjects.DataObject3> id = InstanceIdentifier.create(DataObjects.DataObject3.class);
- final DataObjectUpdate update = mock(DataObjectUpdate.class);
- doReturn(id).when(update).getId();
- final DataObjects.DataObject3 before = mock(DataObjects.DataObject3.class);
- final DataObjects.DataObject3 after = mock(DataObjects.DataObject3.class);
- when(update.getDataBefore()).thenReturn(before);
- when(update.getDataAfter()).thenReturn(after);
-
- WriterRegistry.DataObjectUpdates updates = new WriterRegistry.DataObjectUpdates(
- Multimaps.forMap(Collections.singletonMap(id, update)),
- Multimaps.forMap(Collections.emptyMap()));
- final WriteContext ctx = mock(WriteContext.class);
- build.update(updates, ctx);
-
- verify(writer).update(id, before, after, ctx);
- }
-
- @Test(expected = IllegalArgumentException.class)
- public void testBuildUnknownWriter() throws Exception {
- final FlatWriterRegistryBuilder flatWriterRegistryBuilder = new FlatWriterRegistryBuilder();
- final Writer<? extends DataObject> writer = mockWriter(DataObjects.DataObject3.class);
- flatWriterRegistryBuilder.add(writer);
- final WriterRegistry build = flatWriterRegistryBuilder.build();
-
- final InstanceIdentifier<DataObjects.DataObject1> id2 = InstanceIdentifier.create(DataObjects.DataObject1.class);
- final DataObjectUpdate update2 = mock(DataObjectUpdate.class);
- final WriterRegistry.DataObjectUpdates updates = new WriterRegistry.DataObjectUpdates(
- Multimaps.forMap(Collections.singletonMap(id2, update2)),
- Multimaps.forMap(Collections.emptyMap()));
- build.update(updates, mock(WriteContext.class));
- }
-
- @Test
- public void testRelationsAfter() throws Exception {
- final FlatWriterRegistryBuilder flatWriterRegistryBuilder = new FlatWriterRegistryBuilder();
- /*
- 1 -> 2 -> 3
- -> 4
- */
- flatWriterRegistryBuilder.add(mockWriter(DataObjects.DataObject1.class));
- flatWriterRegistryBuilder.addAfter(mockWriter(DataObjects.DataObject2.class), DataObjects.DataObject1.IID);
- flatWriterRegistryBuilder.addAfter(mockWriter(DataObjects.DataObject3.class), DataObjects.DataObject2.IID);
- flatWriterRegistryBuilder.addAfter(mockWriter(DataObjects.DataObject4.class),
- Lists.newArrayList(DataObjects.DataObject2.IID, DataObjects.DataObject3.IID));
- final ImmutableMap<InstanceIdentifier<?>, Writer<?>> mappedWriters =
- flatWriterRegistryBuilder.getMappedHandlers();
-
- final List<InstanceIdentifier<?>> typesInList = Lists.newArrayList(mappedWriters.keySet());
- assertEquals(DataObjects.DataObject1.IID, typesInList.get(0));
- assertEquals(DataObjects.DataObject2.IID, typesInList.get(1));
- assertThat(typesInList.get(2), anyOf(equalTo(DataObjects.DataObject3.IID), equalTo(DataObjects.DataObject4.IID)));
- assertThat(typesInList.get(3), anyOf(equalTo(DataObjects.DataObject3.IID), equalTo(DataObjects.DataObject4.IID)));
- }
-
- @Test(expected = IllegalArgumentException.class)
- public void testRelationsLoop() throws Exception {
- final FlatWriterRegistryBuilder flatWriterRegistryBuilder = new FlatWriterRegistryBuilder();
- /*
- 1 -> 2 -> 1
- */
- flatWriterRegistryBuilder.add(mockWriter(DataObjects.DataObject1.class));
- flatWriterRegistryBuilder.addAfter(mockWriter(DataObjects.DataObject2.class), DataObjects.DataObject1.IID);
- flatWriterRegistryBuilder.addAfter(mockWriter(DataObjects.DataObject1.class), DataObjects.DataObject2.IID);
- }
-
- @Test(expected = IllegalArgumentException.class)
- public void testAddWriterTwice() throws Exception {
- final FlatWriterRegistryBuilder flatWriterRegistryBuilder = new FlatWriterRegistryBuilder();
- flatWriterRegistryBuilder.add(mockWriter(DataObjects.DataObject1.class));
- flatWriterRegistryBuilder.add(mockWriter(DataObjects.DataObject1.class));
- }
-
- @Test
- public void testAddSubtreeWriter() throws Exception {
- final FlatWriterRegistryBuilder flatWriterRegistryBuilder = new FlatWriterRegistryBuilder();
- flatWriterRegistryBuilder.subtreeAdd(
- Sets.newHashSet(DataObjects.DataObject4.DataObject41.IID,
- DataObjects.DataObject4.DataObject41.IID),
- mockWriter(DataObjects.DataObject4.class));
- final ImmutableMap<InstanceIdentifier<?>, Writer<?>> mappedWriters =
- flatWriterRegistryBuilder.getMappedHandlers();
- final ArrayList<InstanceIdentifier<?>> typesInList = Lists.newArrayList(mappedWriters.keySet());
-
- assertEquals(DataObjects.DataObject4.IID, typesInList.get(0));
- assertEquals(1, typesInList.size());
- }
-
- @Test
- public void testCreateSubtreeWriter() throws Exception {
- final Writer<?> forWriter = SubtreeWriter.createForWriter(Sets.newHashSet(
- DataObjects.DataObject4.DataObject41.IID,
- DataObjects.DataObject4.DataObject41.DataObject411.IID,
- DataObjects.DataObject4.DataObject42.IID),
- mockWriter(DataObjects.DataObject4.class));
- assertThat(forWriter, instanceOf(SubtreeWriter.class));
- assertThat(((SubtreeWriter<?>) forWriter).getHandledChildTypes().size(), is(3));
- assertThat(((SubtreeWriter<?>) forWriter).getHandledChildTypes(), hasItems(DataObjects.DataObject4.DataObject41.IID,
- DataObjects.DataObject4.DataObject42.IID, DataObjects.DataObject4.DataObject41.DataObject411.IID));
- }
-
- @Test(expected = IllegalArgumentException.class)
- public void testCreateInvalidSubtreeWriter() throws Exception {
- SubtreeWriter.createForWriter(Sets.newHashSet(
- InstanceIdentifier.create(DataObjects.DataObject3.class).child(DataObjects.DataObject3.DataObject31.class)),
- mockWriter(DataObjects.DataObject4.class));
- }
-
- @SuppressWarnings("unchecked")
- private Writer<? extends DataObject> mockWriter(final Class<? extends DataObject> doClass)
- throws NoSuchFieldException, IllegalAccessException {
- final Writer mock = mock(Writer.class);
- when(mock.getManagedDataObjectType()).thenReturn((InstanceIdentifier<?>) doClass.getDeclaredField("IID").get(null));
- return mock;
- }
-
-} \ No newline at end of file
diff --git a/infra/translate-utils/src/test/java/io/fd/honeycomb/translate/util/write/registry/FlatWriterRegistryTest.java b/infra/translate-utils/src/test/java/io/fd/honeycomb/translate/util/write/registry/FlatWriterRegistryTest.java
deleted file mode 100644
index 5566fca47..000000000
--- a/infra/translate-utils/src/test/java/io/fd/honeycomb/translate/util/write/registry/FlatWriterRegistryTest.java
+++ /dev/null
@@ -1,328 +0,0 @@
-/*
- * 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.translate.util.write.registry;
-
-import static org.hamcrest.CoreMatchers.is;
-import static org.junit.Assert.assertThat;
-import static org.junit.Assert.fail;
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.eq;
-import static org.mockito.Mockito.doThrow;
-import static org.mockito.Mockito.inOrder;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.verifyNoMoreInteractions;
-import static org.mockito.Mockito.verifyZeroInteractions;
-import static org.mockito.Mockito.when;
-
-import com.google.common.collect.HashMultimap;
-import com.google.common.collect.ImmutableMap;
-import com.google.common.collect.ImmutableMultimap;
-import com.google.common.collect.Multimap;
-import io.fd.honeycomb.translate.util.DataObjects;
-import io.fd.honeycomb.translate.util.DataObjects.DataObject1;
-import io.fd.honeycomb.translate.write.DataObjectUpdate;
-import io.fd.honeycomb.translate.write.WriteContext;
-import io.fd.honeycomb.translate.write.Writer;
-import io.fd.honeycomb.translate.write.registry.WriterRegistry;
-import org.hamcrest.CoreMatchers;
-import org.junit.Before;
-import org.junit.Test;
-import org.mockito.InOrder;
-import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
-import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-
-public class FlatWriterRegistryTest {
-
- @Mock
- private Writer<DataObject1> writer1;
- @Mock
- private Writer<DataObjects.DataObject2> writer2;
- @Mock
- private Writer<DataObjects.DataObject3> writer3;
- @Mock
- private Writer<DataObjects.DataObject1ChildK> writer4;
- @Mock
- private WriteContext ctx;
- @Mock
- private WriteContext revertWriteContext;
-
- @Before
- public void setUp() throws Exception {
- MockitoAnnotations.initMocks(this);
- when(writer1.getManagedDataObjectType()).thenReturn(DataObjects.DataObject1.IID);
- when(writer2.getManagedDataObjectType()).thenReturn(DataObjects.DataObject2.IID);
- when(writer3.getManagedDataObjectType()).thenReturn(DataObjects.DataObject3.IID);
- }
-
- @Test
- public void testMultipleUpdatesForSingleWriter() throws Exception {
- final FlatWriterRegistry flatWriterRegistry =
- new FlatWriterRegistry(ImmutableMap.of(DataObjects.DataObject1.IID, writer1, DataObjects.DataObject2.IID, writer2));
-
- final Multimap<InstanceIdentifier<?>, DataObjectUpdate> updates = HashMultimap.create();
- final InstanceIdentifier<DataObjects.DataObject1> iid = InstanceIdentifier.create(DataObjects.DataObject1.class);
- final InstanceIdentifier<DataObjects.DataObject1> iid2 = InstanceIdentifier.create(DataObjects.DataObject1.class);
- final DataObjects.DataObject1 dataObject = mock(DataObjects.DataObject1.class);
- updates.put(DataObjects.DataObject1.IID, DataObjectUpdate.create(iid, dataObject, dataObject));
- updates.put(DataObjects.DataObject1.IID, DataObjectUpdate.create(iid2, dataObject, dataObject));
- flatWriterRegistry.update(new WriterRegistry.DataObjectUpdates(updates, ImmutableMultimap.of()), ctx);
-
- verify(writer1).update(iid, dataObject, dataObject, ctx);
- verify(writer1).update(iid2, dataObject, dataObject, ctx);
- // Invoked when registry is being created
- verifyNoMoreInteractions(writer1);
- verifyZeroInteractions(writer2);
- }
-
- @Test
- public void testMultipleUpdatesForMultipleWriters() throws Exception {
- final FlatWriterRegistry flatWriterRegistry =
- new FlatWriterRegistry(ImmutableMap.of(DataObjects.DataObject1.IID, writer1, DataObjects.DataObject2.IID, writer2));
-
- final Multimap<InstanceIdentifier<?>, DataObjectUpdate> updates = HashMultimap.create();
- final InstanceIdentifier<DataObjects.DataObject1> iid = InstanceIdentifier.create(DataObjects.DataObject1.class);
- final DataObjects.DataObject1 dataObject = mock(DataObjects.DataObject1.class);
- updates.put(DataObjects.DataObject1.IID, DataObjectUpdate.create(iid, dataObject, dataObject));
- final InstanceIdentifier<DataObjects.DataObject2> iid2 = InstanceIdentifier.create(DataObjects.DataObject2.class);
- final DataObjects.DataObject2 dataObject2 = mock(DataObjects.DataObject2.class);
- updates.put(DataObjects.DataObject2.IID, DataObjectUpdate.create(iid2, dataObject2, dataObject2));
- flatWriterRegistry.update(new WriterRegistry.DataObjectUpdates(updates, ImmutableMultimap.of()), ctx);
-
- final InOrder inOrder = inOrder(writer1, writer2);
- inOrder.verify(writer1).update(iid, dataObject, dataObject, ctx);
- inOrder.verify(writer2).update(iid2, dataObject2, dataObject2, ctx);
-
- verifyNoMoreInteractions(writer1);
- verifyNoMoreInteractions(writer2);
- }
-
- @Test
- public void testMultipleDeletesForMultipleWriters() throws Exception {
- final FlatWriterRegistry flatWriterRegistry =
- new FlatWriterRegistry(ImmutableMap.of(DataObjects.DataObject1.IID, writer1, DataObjects.DataObject2.IID, writer2));
-
- final Multimap<InstanceIdentifier<?>, DataObjectUpdate.DataObjectDelete> deletes = HashMultimap.create();
- final InstanceIdentifier<DataObjects.DataObject1> iid = InstanceIdentifier.create(DataObjects.DataObject1.class);
- final DataObjects.DataObject1 dataObject = mock(DataObjects.DataObject1.class);
- deletes.put(DataObjects.DataObject1.IID, ((DataObjectUpdate.DataObjectDelete) DataObjectUpdate.create(iid, dataObject, null)));
- final InstanceIdentifier<DataObjects.DataObject2> iid2 = InstanceIdentifier.create(DataObjects.DataObject2.class);
- final DataObjects.DataObject2 dataObject2 = mock(DataObjects.DataObject2.class);
- deletes.put(DataObjects.DataObject2.IID, ((DataObjectUpdate.DataObjectDelete) DataObjectUpdate.create(iid2, dataObject2, null)));
- flatWriterRegistry.update(new WriterRegistry.DataObjectUpdates(ImmutableMultimap.of(), deletes), ctx);
-
- final InOrder inOrder = inOrder(writer1, writer2);
- // Reversed order of invocation, first writer2 and then writer1
- inOrder.verify(writer2).update(iid2, dataObject2, null, ctx);
- inOrder.verify(writer1).update(iid, dataObject, null, ctx);
-
- verifyNoMoreInteractions(writer1);
- verifyNoMoreInteractions(writer2);
- }
-
- @Test
- public void testMultipleUpdatesAndDeletesForMultipleWriters() throws Exception {
- final FlatWriterRegistry flatWriterRegistry =
- new FlatWriterRegistry(ImmutableMap.of(DataObjects.DataObject1.IID, writer1, DataObjects.DataObject2.IID, writer2));
-
- final Multimap<InstanceIdentifier<?>, DataObjectUpdate.DataObjectDelete> deletes = HashMultimap.create();
- final Multimap<InstanceIdentifier<?>, DataObjectUpdate> updates = HashMultimap.create();
- final InstanceIdentifier<DataObjects.DataObject1> iid = InstanceIdentifier.create(DataObjects.DataObject1.class);
- final DataObjects.DataObject1 dataObject = mock(DataObjects.DataObject1.class);
- // Writer 1 delete
- deletes.put(DataObjects.DataObject1.IID, ((DataObjectUpdate.DataObjectDelete) DataObjectUpdate.create(iid, dataObject, null)));
- // Writer 1 update
- updates.put(DataObjects.DataObject1.IID, DataObjectUpdate.create(iid, dataObject, dataObject));
- final InstanceIdentifier<DataObjects.DataObject2> iid2 = InstanceIdentifier.create(DataObjects.DataObject2.class);
- final DataObjects.DataObject2 dataObject2 = mock(DataObjects.DataObject2.class);
- // Writer 2 delete
- deletes.put(DataObjects.DataObject2.IID, ((DataObjectUpdate.DataObjectDelete) DataObjectUpdate.create(iid2, dataObject2, null)));
- // Writer 2 update
- updates.put(DataObjects.DataObject2.IID, DataObjectUpdate.create(iid2, dataObject2, dataObject2));
- flatWriterRegistry.update(new WriterRegistry.DataObjectUpdates(updates, deletes), ctx);
-
- final InOrder inOrder = inOrder(writer1, writer2);
- // Reversed order of invocation, first writer2 and then writer1 for deletes
- inOrder.verify(writer2).update(iid2, dataObject2, null, ctx);
- inOrder.verify(writer1).update(iid, dataObject, null, ctx);
- // Then also updates are processed
- inOrder.verify(writer1).update(iid, dataObject, dataObject, ctx);
- inOrder.verify(writer2).update(iid2, dataObject2, dataObject2, ctx);
-
- verifyNoMoreInteractions(writer1);
- verifyNoMoreInteractions(writer2);
- }
-
- @Test(expected = IllegalArgumentException.class)
- public void testMultipleUpdatesOneMissing() throws Exception {
- final FlatWriterRegistry flatWriterRegistry =
- new FlatWriterRegistry(ImmutableMap.of(DataObjects.DataObject1.IID, writer1));
-
- final Multimap<InstanceIdentifier<?>, DataObjectUpdate> updates = HashMultimap.create();
- addUpdate(updates, DataObjects.DataObject1.class);
- addUpdate(updates, DataObjects.DataObject2.class);
- flatWriterRegistry.update(new WriterRegistry.DataObjectUpdates(updates, ImmutableMultimap.of()), ctx);
- }
-
- @Test
- public void testMultipleUpdatesOneFailing() throws Exception {
- final FlatWriterRegistry flatWriterRegistry =
- new FlatWriterRegistry(ImmutableMap.of(DataObjects.DataObject1.IID, writer1, DataObjects.DataObject2.IID, writer2));
-
- // Writer1 always fails
- doThrow(new RuntimeException()).when(writer1)
- .update(any(InstanceIdentifier.class), any(DataObject.class), any(DataObject.class), any(WriteContext.class));
-
- final Multimap<InstanceIdentifier<?>, DataObjectUpdate> updates = HashMultimap.create();
- addUpdate(updates, DataObjects.DataObject1.class);
- addUpdate(updates, DataObjects.DataObject2.class);
-
- try {
- flatWriterRegistry.update(new WriterRegistry.DataObjectUpdates(updates, ImmutableMultimap.of()), ctx);
- fail("Bulk update should have failed on writer1");
- } catch (WriterRegistry.BulkUpdateException e) {
- assertThat(e.getFailedIds().size(), is(2));
- assertThat(e.getFailedIds(), CoreMatchers.hasItem(InstanceIdentifier.create(DataObjects.DataObject2.class)));
- assertThat(e.getFailedIds(), CoreMatchers.hasItem(InstanceIdentifier.create(DataObjects.DataObject1.class)));
- }
- }
-
- @Test
- public void testMultipleUpdatesOneFailingThenRevertWithSuccess() throws Exception {
- final FlatWriterRegistry flatWriterRegistry =
- new FlatWriterRegistry(
- ImmutableMap.of(DataObjects.DataObject1.IID, writer1, DataObjects.DataObject2.IID, writer2, DataObjects.DataObject3.IID, writer3));
-
- // Writer1 always fails
- doThrow(new RuntimeException()).when(writer3)
- .update(any(InstanceIdentifier.class), any(DataObject.class), any(DataObject.class), any(WriteContext.class));
-
- final Multimap<InstanceIdentifier<?>, DataObjectUpdate> updates = HashMultimap.create();
- addUpdate(updates, DataObjects.DataObject1.class);
- addUpdate(updates, DataObjects.DataObject3.class);
- final InstanceIdentifier<DataObjects.DataObject2> iid2 = InstanceIdentifier.create(DataObjects.DataObject2.class);
- final DataObjects.DataObject2 before2 = mock(DataObjects.DataObject2.class);
- final DataObjects.DataObject2 after2 = mock(DataObjects.DataObject2.class);
- updates.put(DataObjects.DataObject2.IID, DataObjectUpdate.create(iid2, before2, after2));
-
- try {
- flatWriterRegistry.update(new WriterRegistry.DataObjectUpdates(updates, ImmutableMultimap.of()), ctx);
- fail("Bulk update should have failed on writer1");
- } catch (WriterRegistry.BulkUpdateException e) {
- assertThat(e.getFailedIds().size(), is(1));
-
- final InOrder inOrder = inOrder(writer1, writer2, writer3);
- inOrder.verify(writer1)
- .update(any(InstanceIdentifier.class), any(DataObject.class), any(DataObject.class), any(WriteContext.class));
- inOrder.verify(writer2)
- .update(iid2, before2, after2, ctx);
- inOrder.verify(writer3)
- .update(any(InstanceIdentifier.class), any(DataObject.class), any(DataObject.class), any(WriteContext.class));
-
- e.revertChanges(revertWriteContext);
- // Revert changes. Successful updates are iterated in reverse
- // also binding other write context,to verify if update context is not reused
- inOrder.verify(writer2)
- .update(iid2, after2, before2, revertWriteContext);
- inOrder.verify(writer1)
- .update(any(InstanceIdentifier.class), any(DataObject.class), any(DataObject.class), eq(revertWriteContext));
- verifyNoMoreInteractions(writer3);
- }
- }
-
- @Test
- public void testMultipleUpdatesOneFailingThenRevertWithFail() throws Exception {
- final FlatWriterRegistry flatWriterRegistry =
- new FlatWriterRegistry(
- ImmutableMap.of(DataObjects.DataObject1.IID, writer1, DataObjects.DataObject2.IID, writer2, DataObjects.DataObject3.IID, writer3));
-
- // Writer1 always fails
- doThrow(new RuntimeException()).when(writer3)
- .update(any(InstanceIdentifier.class), any(DataObject.class), any(DataObject.class), any(WriteContext.class));
-
- final Multimap<InstanceIdentifier<?>, DataObjectUpdate> updates = HashMultimap.create();
- addUpdate(updates, DataObjects.DataObject1.class);
- addUpdate(updates, DataObjects.DataObject2.class);
- addUpdate(updates, DataObjects.DataObject3.class);
-
- try {
- flatWriterRegistry.update(new WriterRegistry.DataObjectUpdates(updates, ImmutableMultimap.of()), ctx);
- fail("Bulk update should have failed on writer1");
- } catch (WriterRegistry.BulkUpdateException e) {
- // Writer1 always fails from now
- doThrow(new RuntimeException()).when(writer1)
- .update(any(InstanceIdentifier.class), any(DataObject.class), any(DataObject.class), any(WriteContext.class));
- try {
- e.revertChanges(revertWriteContext);
- } catch (WriterRegistry.Reverter.RevertFailedException e1) {
- assertThat(e1.getNotRevertedChanges().size(), is(1));
- assertThat(e1.getNotRevertedChanges(), CoreMatchers
- .hasItem(InstanceIdentifier.create(DataObjects.DataObject1.class)));
- }
- }
- }
-
- @Test
- public void testMutlipleUpdatesWithOneKeyedContainer() throws Exception {
- final InstanceIdentifier internallyKeyedIdentifier = InstanceIdentifier.create(DataObject1.class)
- .child(DataObjects.DataObject1ChildK.class, new DataObjects.DataObject1ChildKey());
-
- final FlatWriterRegistry flatWriterRegistry =
- new FlatWriterRegistry(
- ImmutableMap.of(DataObjects.DataObject1.IID, writer1, DataObjects.DataObject1ChildK.IID,writer4));
-
- // Writer1 always fails
- doThrow(new RuntimeException()).when(writer1)
- .update(any(InstanceIdentifier.class), any(DataObject.class), any(DataObject.class),
- any(WriteContext.class));
-
- final Multimap<InstanceIdentifier<?>, DataObjectUpdate> updates = HashMultimap.create();
- addKeyedUpdate(updates,DataObjects.DataObject1ChildK.class);
- addUpdate(updates, DataObjects.DataObject1.class);
- try {
- flatWriterRegistry.update(new WriterRegistry.DataObjectUpdates(updates, ImmutableMultimap.of()), ctx);
- fail("Bulk update should have failed on writer1");
- } catch (WriterRegistry.BulkUpdateException e) {
- // Writer1 always fails from now
- doThrow(new RuntimeException()).when(writer1)
- .update(any(InstanceIdentifier.class), any(DataObject.class), any(DataObject.class),
- any(WriteContext.class));
- try {
- e.revertChanges(revertWriteContext);
- } catch (WriterRegistry.Reverter.RevertFailedException e1) {
- assertThat(e1.getNotRevertedChanges().size(), is(1));
- assertThat(e1.getNotRevertedChanges(), CoreMatchers
- .hasItem(InstanceIdentifier.create(DataObjects.DataObject1.class)));
- }
- }
- }
-
- private <D extends DataObject> void addKeyedUpdate(final Multimap<InstanceIdentifier<?>, DataObjectUpdate> updates,
- final Class<D> type) throws Exception {
- final InstanceIdentifier<D> iid = (InstanceIdentifier<D>) type.getDeclaredField("IID").get(null);
- final InstanceIdentifier<D> keyedIid = (InstanceIdentifier<D>) type.getDeclaredField("INTERNALLY_KEYED_IID").get(null);
- updates.put(iid, DataObjectUpdate.create(keyedIid, mock(type), mock(type)));
- }
-
- private <D extends DataObject> void addUpdate(final Multimap<InstanceIdentifier<?>, DataObjectUpdate> updates,
- final Class<D> type) throws Exception {
- final InstanceIdentifier<D> iid = (InstanceIdentifier<D>) type.getDeclaredField("IID").get(null);
- updates.put(iid, DataObjectUpdate.create(iid, mock(type), mock(type)));
- }
-} \ No newline at end of file
diff --git a/infra/translate-utils/src/test/java/io/fd/honeycomb/translate/util/write/registry/SubtreeWriterTest.java b/infra/translate-utils/src/test/java/io/fd/honeycomb/translate/util/write/registry/SubtreeWriterTest.java
deleted file mode 100644
index 313dd34a8..000000000
--- a/infra/translate-utils/src/test/java/io/fd/honeycomb/translate/util/write/registry/SubtreeWriterTest.java
+++ /dev/null
@@ -1,84 +0,0 @@
-/*
- * 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.translate.util.write.registry;
-
-import static org.hamcrest.CoreMatchers.hasItem;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertThat;
-import static org.mockito.Mockito.when;
-
-import com.google.common.collect.Sets;
-import io.fd.honeycomb.translate.util.DataObjects;
-import io.fd.honeycomb.translate.write.Writer;
-import java.util.Collections;
-import org.junit.Before;
-import org.junit.Test;
-import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
-import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-
-public class SubtreeWriterTest {
-
- @Mock
- Writer<DataObjects.DataObject4> writer;
- @Mock
- Writer<DataObjects.DataObject4.DataObject41> writer11;
-
- @Before
- public void setUp() throws Exception {
- MockitoAnnotations.initMocks(this);
- when(writer.getManagedDataObjectType()).thenReturn(DataObjects.DataObject4.IID);
- when(writer11.getManagedDataObjectType()).thenReturn(DataObjects.DataObject4.DataObject41.IID);
- }
-
- @Test(expected = IllegalArgumentException.class)
- public void testSubtreeWriterCreationFail() throws Exception {
- // The subtree node identified by IID.c(DataObject.class) is not a child of writer.getManagedDataObjectType
- SubtreeWriter.createForWriter(Collections.singleton(InstanceIdentifier.create(DataObject.class)), writer);
- }
-
- @Test(expected = IllegalArgumentException.class)
- public void testSubtreeWriterCreationFailInvalidIid() throws Exception {
- // The subtree node identified by IID.c(DataObject.class) is not a child of writer.getManagedDataObjectType
- SubtreeWriter.createForWriter(Collections.singleton(DataObjects.DataObject4.IID), writer);
- }
-
- @Test
- public void testSubtreeWriterCreation() throws Exception {
- final SubtreeWriter<?> forWriter = (SubtreeWriter<?>) SubtreeWriter.createForWriter(Sets.newHashSet(
- DataObjects.DataObject4.DataObject41.IID,
- DataObjects.DataObject4.DataObject41.DataObject411.IID,
- DataObjects.DataObject4.DataObject42.IID),
- writer);
-
- assertEquals(writer.getManagedDataObjectType(), forWriter.getManagedDataObjectType());
- assertEquals(3, forWriter.getHandledChildTypes().size());
- }
-
- @Test
- public void testSubtreeWriterHandledTypes() throws Exception {
- final SubtreeWriter<?> forWriter = (SubtreeWriter<?>) SubtreeWriter.createForWriter(Sets.newHashSet(
- DataObjects.DataObject4.DataObject41.DataObject411.IID),
- writer);
-
- assertEquals(writer.getManagedDataObjectType(), forWriter.getManagedDataObjectType());
- assertEquals(1, forWriter.getHandledChildTypes().size());
- assertThat(forWriter.getHandledChildTypes(), hasItem(DataObjects.DataObject4.DataObject41.DataObject411.IID));
- }
-
-} \ No newline at end of file