From b16cea20258ba537db7c0755208c82ab93331ff7 Mon Sep 17 00:00:00 2001 From: Michal Cmarada Date: Mon, 8 Apr 2019 11:37:45 +0200 Subject: HONEYCOMB-443: ODL bump to Neon - bumps ODL dependencies to neon - migrates guava optional to java.utils.optional Change-Id: Ibdaa365c7e21a341103aba88dfd67277e40d2969 Signed-off-by: Michal Cmarada --- .../io/fd/honeycomb/translate/util/RWUtils.java | 6 +- .../translate/util/RealtimeMappingContext.java | 35 ++++++----- .../honeycomb/translate/util/ReflectionUtils.java | 6 +- .../translate/util/TransactionMappingContext.java | 22 +++---- .../translate/util/read/AbstractGenericReader.java | 6 +- .../translate/util/read/BindingBrokerReader.java | 23 +++---- .../translate/util/read/DelegatingReader.java | 2 +- .../util/read/KeepaliveReaderWrapper.java | 4 +- .../util/read/ReflexiveListReaderCustomizer.java | 2 +- .../util/read/ReflexiveReaderCustomizer.java | 2 +- .../util/read/cache/DumpCacheManager.java | 6 +- .../translate/util/write/BindingBrokerWriter.java | 26 ++++---- .../util/write/LegacyBindingBrokerWriter.java | 70 ++++++++++++++++++++++ .../util/write/TransactionWriteContext.java | 29 +++++---- .../write/util/TransactionWriteContextTest.java | 22 +++---- .../translate/util/RealtimeMappingContextTest.java | 50 ++++++++-------- .../util/TransactionMappingContextTest.java | 24 ++++---- .../util/read/BindingBrokerReaderTest.java | 19 +++--- .../read/ReflexiveListReaderCustomizerTest.java | 2 +- .../util/read/cache/DumpCacheManagerTest.java | 2 +- .../util/write/BindingBrokerWriterTest.java | 15 +++-- 21 files changed, 221 insertions(+), 152 deletions(-) create mode 100644 infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/write/LegacyBindingBrokerWriter.java (limited to 'infra/translate-utils') diff --git a/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/RWUtils.java b/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/RWUtils.java index 71bcd9def..2bd2de1ec 100644 --- a/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/RWUtils.java +++ b/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/RWUtils.java @@ -101,7 +101,7 @@ public final class RWUtils { @Nonnull public static , K extends Identifier> InstanceIdentifier.IdentifiableItem getCurrentIdItem( @Nonnull final InstanceIdentifier id, final K key) { - return new InstanceIdentifier.IdentifiableItem<>(id.getTargetType(), key); + return InstanceIdentifier.IdentifiableItem.of(id.getTargetType(), key); } /** @@ -160,7 +160,7 @@ public final class RWUtils { */ @SuppressWarnings("unchecked") public static InstanceIdentifier makeIidLastWildcarded(final InstanceIdentifier id) { - final InstanceIdentifier.Item wildcardedItem = new InstanceIdentifier.Item<>(id.getTargetType()); + final InstanceIdentifier.Item wildcardedItem = InstanceIdentifier.Item.of(id.getTargetType()); final Iterable pathArguments = id.getPathArguments(); return (InstanceIdentifier) InstanceIdentifier.create( Iterables.concat( @@ -170,7 +170,7 @@ public final class RWUtils { private static InstanceIdentifier.PathArgument cleanPathArgumentFromKeys(final InstanceIdentifier.PathArgument pathArgument) { return pathArgument instanceof InstanceIdentifier.IdentifiableItem - ? new InstanceIdentifier.Item<>(pathArgument.getType()) + ? InstanceIdentifier.Item.of(pathArgument.getType()) : pathArgument; } } diff --git a/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/RealtimeMappingContext.java b/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/RealtimeMappingContext.java index f10d312f1..09dba79da 100644 --- a/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/RealtimeMappingContext.java +++ b/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/RealtimeMappingContext.java @@ -16,15 +16,14 @@ package io.fd.honeycomb.translate.util; -import com.google.common.base.Optional; import io.fd.honeycomb.translate.MappingContext; +import java.util.Optional; +import java.util.concurrent.ExecutionException; import javax.annotation.Nonnull; -import org.opendaylight.controller.md.sal.binding.api.DataBroker; -import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction; -import org.opendaylight.controller.md.sal.binding.api.WriteTransaction; -import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; -import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException; -import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException; +import org.opendaylight.mdsal.binding.api.DataBroker; +import org.opendaylight.mdsal.binding.api.ReadTransaction; +import org.opendaylight.mdsal.binding.api.WriteTransaction; +import org.opendaylight.mdsal.common.api.LogicalDatastoreType; import org.opendaylight.yangtools.yang.binding.DataObject; import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; @@ -38,10 +37,10 @@ public final class RealtimeMappingContext implements MappingContext { @Override public Optional read(@Nonnull final InstanceIdentifier currentId) { - try (ReadOnlyTransaction tx = contextBindingBrokerDependency.newReadOnlyTransaction()) { + try (ReadTransaction tx = contextBindingBrokerDependency.newReadOnlyTransaction()) { try { - return tx.read(LogicalDatastoreType.OPERATIONAL, currentId).checkedGet(); - } catch (ReadFailedException e) { + return tx.read(LogicalDatastoreType.OPERATIONAL, currentId).get(); + } catch (InterruptedException | ExecutionException e) { throw new IllegalStateException("Unable to perform read of " + currentId, e); } } @@ -52,8 +51,8 @@ public final class RealtimeMappingContext implements MappingContext { final WriteTransaction writeTx = contextBindingBrokerDependency.newWriteOnlyTransaction(); writeTx.delete(LogicalDatastoreType.OPERATIONAL, path); try { - writeTx.submit().checkedGet(); - } catch (TransactionCommitFailedException e) { + writeTx.commit().get(); + } catch (InterruptedException | ExecutionException e) { throw new IllegalStateException("Unable to perform delete of " + path, e); } } @@ -61,10 +60,10 @@ public final class RealtimeMappingContext implements MappingContext { @Override public void merge(final InstanceIdentifier path, final T data) { final WriteTransaction writeTx = contextBindingBrokerDependency.newWriteOnlyTransaction(); - writeTx.merge(LogicalDatastoreType.OPERATIONAL, path, data, true); + writeTx.mergeParentStructureMerge(LogicalDatastoreType.OPERATIONAL, path, data); try { - writeTx.submit().checkedGet(); - } catch (TransactionCommitFailedException e) { + writeTx.commit().get(); + } catch (InterruptedException | ExecutionException e) { throw new IllegalStateException("Unable to perform merge of " + path, e); } } @@ -72,10 +71,10 @@ public final class RealtimeMappingContext implements MappingContext { @Override public void put(final InstanceIdentifier path, final T data) { final WriteTransaction writeTx = contextBindingBrokerDependency.newWriteOnlyTransaction(); - writeTx.put(LogicalDatastoreType.OPERATIONAL, path, data, true); + writeTx.mergeParentStructurePut(LogicalDatastoreType.OPERATIONAL, path, data); try { - writeTx.submit().checkedGet(); - } catch (TransactionCommitFailedException e) { + writeTx.commit().get(); + } catch (InterruptedException | ExecutionException e) { throw new IllegalStateException("Unable to perform put of " + path, e); } } diff --git a/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/ReflectionUtils.java b/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/ReflectionUtils.java index 74c7be97c..7e1099ab7 100644 --- a/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/ReflectionUtils.java +++ b/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/ReflectionUtils.java @@ -16,9 +16,9 @@ package io.fd.honeycomb.translate.util; -import com.google.common.base.Optional; import java.lang.reflect.Method; import java.util.List; +import java.util.Optional; import javax.annotation.Nonnull; /** @@ -36,7 +36,7 @@ public final class ReflectionUtils { * @param paramTypes List of input argument types * @param retType Return type * - * @return Found method or Optional.absent() if there's no such method + * @return Found method or Optional.empty() if there's no such method */ @Nonnull public static Optional findMethodReflex(@Nonnull final Class managedType, @@ -49,7 +49,7 @@ public final class ReflectionUtils { } } - return Optional.absent(); + return Optional.empty(); } private static boolean isMethodMatch(final @Nonnull String prefix, diff --git a/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/TransactionMappingContext.java b/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/TransactionMappingContext.java index 4d4e9fddd..33753bbca 100644 --- a/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/TransactionMappingContext.java +++ b/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/TransactionMappingContext.java @@ -16,14 +16,14 @@ package io.fd.honeycomb.translate.util; -import com.google.common.base.Optional; -import com.google.common.util.concurrent.CheckedFuture; +import com.google.common.util.concurrent.FluentFuture; import io.fd.honeycomb.translate.MappingContext; +import java.util.Optional; +import java.util.concurrent.ExecutionException; import javax.annotation.Nonnull; -import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction; -import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; -import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException; -import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException; +import org.opendaylight.mdsal.binding.api.ReadWriteTransaction; +import org.opendaylight.mdsal.common.api.CommitInfo; +import org.opendaylight.mdsal.common.api.LogicalDatastoreType; import org.opendaylight.yangtools.yang.binding.DataObject; import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; @@ -43,9 +43,9 @@ public class TransactionMappingContext implements MappingContext { @Override public Optional read(@Nonnull final InstanceIdentifier currentId) { try { - return readWriteTransaction.read(LogicalDatastoreType.OPERATIONAL, currentId).checkedGet(); - } catch (ReadFailedException e) { - throw new IllegalStateException("Unable to perform read", e); + return readWriteTransaction.read(LogicalDatastoreType.OPERATIONAL, currentId).get(); + } catch (InterruptedException | ExecutionException ex) { + throw new IllegalStateException("Unable to perform read", ex); } } @@ -64,8 +64,8 @@ public class TransactionMappingContext implements MappingContext { readWriteTransaction.put(LogicalDatastoreType.OPERATIONAL, path, data, true); } - public CheckedFuture submit() { - return readWriteTransaction.submit(); + public FluentFuture commit() { + return readWriteTransaction.commit(); } @Override 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 b19b72ecf..897174e1f 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 @@ -19,11 +19,11 @@ package io.fd.honeycomb.translate.util.read; import static com.google.common.base.Preconditions.checkArgument; import com.google.common.annotations.Beta; -import com.google.common.base.Optional; 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.read.ReadFailedException; +import java.util.Optional; import javax.annotation.Nonnull; import org.opendaylight.yangtools.concepts.Builder; import org.opendaylight.yangtools.yang.binding.DataObject; @@ -64,7 +64,7 @@ public abstract class AbstractGenericReader read = isPresent(id, built, ctx) ? Optional.of(built) - : Optional.absent(); + : Optional.empty(); 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 e59e642c4..843175878 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 @@ -16,15 +16,16 @@ package io.fd.honeycomb.translate.util.read; -import com.google.common.base.Optional; -import com.google.common.util.concurrent.CheckedFuture; +import com.google.common.util.concurrent.FluentFuture; import io.fd.honeycomb.translate.read.ReadContext; -import io.fd.honeycomb.translate.read.Reader; import io.fd.honeycomb.translate.read.ReadFailedException; +import io.fd.honeycomb.translate.read.Reader; +import java.util.Optional; +import java.util.concurrent.ExecutionException; import javax.annotation.Nonnull; -import org.opendaylight.controller.md.sal.binding.api.DataBroker; -import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction; -import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; +import org.opendaylight.mdsal.binding.api.DataBroker; +import org.opendaylight.mdsal.binding.api.ReadTransaction; +import org.opendaylight.mdsal.common.api.LogicalDatastoreType; import org.opendaylight.yangtools.concepts.Builder; import org.opendaylight.yangtools.yang.binding.DataObject; import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; @@ -59,13 +60,13 @@ public final class BindingBrokerReader read(@Nonnull final InstanceIdentifier id, @Nonnull final ReadContext ctx) throws ReadFailedException { - try (final ReadOnlyTransaction readOnlyTransaction = dataBroker.newReadOnlyTransaction()) { - final CheckedFuture, org.opendaylight.controller.md.sal.common.api.data.ReadFailedException> + try (final ReadTransaction readOnlyTransaction = dataBroker.newReadOnlyTransaction()) { + final FluentFuture> read = readOnlyTransaction.read(datastoreType, id); try { - return read.checkedGet(); - } catch (org.opendaylight.controller.md.sal.common.api.data.ReadFailedException e) { - throw new ReadFailedException(id, e); + return read.get(); + } catch (InterruptedException | ExecutionException ex) { + throw new ReadFailedException(id, ex); } } } 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 index 5e2e7062e..8d3eb4cbc 100644 --- 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 @@ -16,12 +16,12 @@ 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 java.util.Optional; import javax.annotation.Nonnull; import org.opendaylight.yangtools.concepts.Builder; import org.opendaylight.yangtools.yang.binding.DataObject; 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 b4d8be495..249fca642 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 @@ -16,13 +16,13 @@ package io.fd.honeycomb.translate.util.read; -import com.google.common.base.Optional; import com.google.common.base.Preconditions; import io.fd.honeycomb.translate.MappingContext; import io.fd.honeycomb.translate.ModificationCache; import io.fd.honeycomb.translate.read.ReadContext; import io.fd.honeycomb.translate.read.Reader; import java.io.Closeable; +import java.util.Optional; import java.util.concurrent.ScheduledExecutorService; import java.util.concurrent.ScheduledFuture; import java.util.concurrent.TimeUnit; @@ -110,7 +110,7 @@ public final class KeepaliveReaderWrapper Optional read(@Nonnull final InstanceIdentifier currentId) { - return Optional.absent(); + return Optional.empty(); } @Override diff --git a/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/ReflexiveListReaderCustomizer.java b/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/ReflexiveListReaderCustomizer.java index daf6f3566..7ad04399f 100644 --- a/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/ReflexiveListReaderCustomizer.java +++ b/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/ReflexiveListReaderCustomizer.java @@ -20,7 +20,6 @@ import static com.google.common.base.Preconditions.checkArgument; import static com.google.common.base.Preconditions.checkNotNull; import static com.google.common.base.Preconditions.checkState; -import com.google.common.base.Optional; import io.fd.honeycomb.translate.read.ReadContext; import io.fd.honeycomb.translate.read.ReadFailedException; import io.fd.honeycomb.translate.spi.read.ListReaderCustomizer; @@ -29,6 +28,7 @@ import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; import java.util.Collections; import java.util.List; +import java.util.Optional; import javax.annotation.Nonnull; import org.opendaylight.yangtools.concepts.Builder; import org.opendaylight.yangtools.yang.binding.DataObject; 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 087873306..a70ccef53 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 @@ -18,12 +18,12 @@ package io.fd.honeycomb.translate.util.read; import static com.google.common.base.Preconditions.checkArgument; -import com.google.common.base.Optional; import com.google.common.collect.Lists; import io.fd.honeycomb.translate.util.ReflectionUtils; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; import java.util.Collections; +import java.util.Optional; import javax.annotation.Nonnull; import org.opendaylight.yangtools.concepts.Builder; import org.opendaylight.yangtools.yang.binding.Augmentation; diff --git a/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/cache/DumpCacheManager.java b/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/cache/DumpCacheManager.java index a0856793d..a9e958240 100644 --- a/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/cache/DumpCacheManager.java +++ b/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/read/cache/DumpCacheManager.java @@ -20,10 +20,10 @@ import static com.google.common.base.Preconditions.checkNotNull; import static com.google.common.base.Preconditions.checkState; import static java.util.Objects.nonNull; -import com.google.common.base.Optional; import io.fd.honeycomb.translate.ModificationCache; import io.fd.honeycomb.translate.read.ReadFailedException; import io.fd.honeycomb.translate.util.read.cache.noop.NoopDumpPostProcessingFunction; +import java.util.Optional; import javax.annotation.Nonnull; import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; import org.slf4j.Logger; @@ -59,7 +59,7 @@ public final class DumpCacheManager { * @param cache modification cache of current transaction * @throws ReadFailedException if execution of dumping request failed * @returns If present in cache ,returns cached instance, if not, tries to dump data using provided executor, - * otherwise Optional.absent() + * otherwise Optional.empty() */ public Optional getDump(@Nonnull final InstanceIdentifier identifier, @Nonnull final ModificationCache cache) @@ -75,7 +75,7 @@ public final class DumpCacheManager { * @param dumpParams parameters to configure dump request * @throws ReadFailedException if execution of dumping request failed * @returns If present in cache ,returns cached instance, if not, tries to dump data using provided executor, - * otherwise Optional.absent() + * otherwise Optional.empty() */ public Optional getDump(@Nonnull final InstanceIdentifier identifier, @Nonnull final ModificationCache cache, final U dumpParams) diff --git a/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/write/BindingBrokerWriter.java b/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/write/BindingBrokerWriter.java index 60a81a77a..22e30bd9e 100644 --- a/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/write/BindingBrokerWriter.java +++ b/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/write/BindingBrokerWriter.java @@ -16,20 +16,20 @@ package io.fd.honeycomb.translate.util.write; -import com.google.common.util.concurrent.CheckedFuture; +import static org.opendaylight.mdsal.common.api.LogicalDatastoreType.CONFIGURATION; + +import com.google.common.util.concurrent.FluentFuture; import io.fd.honeycomb.translate.write.WriteContext; import io.fd.honeycomb.translate.write.WriteFailedException; import io.fd.honeycomb.translate.write.Writer; -import org.opendaylight.controller.md.sal.binding.api.DataBroker; -import org.opendaylight.controller.md.sal.binding.api.WriteTransaction; -import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException; -import org.opendaylight.yangtools.yang.binding.DataObject; -import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; - +import java.util.concurrent.ExecutionException; import javax.annotation.Nonnull; import javax.annotation.Nullable; - -import static org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType.CONFIGURATION; +import org.opendaylight.mdsal.binding.api.DataBroker; +import org.opendaylight.mdsal.binding.api.WriteTransaction; +import org.opendaylight.mdsal.common.api.CommitInfo; +import org.opendaylight.yangtools.yang.binding.DataObject; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; /** * Simple DataBroker backed writer allowing to delegate writes to different brokers. @@ -55,11 +55,11 @@ public final class BindingBrokerWriter implements Writer) id, dataAfter); - final CheckedFuture result = writeTransaction.submit(); + final FluentFuture result = writeTransaction.commit(); try { - result.checkedGet(); - } catch (TransactionCommitFailedException e) { - throw new WriteFailedException(id, e); + result.get(); + } catch (InterruptedException | ExecutionException ex) { + throw new WriteFailedException(id, ex); } } diff --git a/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/write/LegacyBindingBrokerWriter.java b/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/write/LegacyBindingBrokerWriter.java new file mode 100644 index 000000000..f6c2f0ffa --- /dev/null +++ b/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/write/LegacyBindingBrokerWriter.java @@ -0,0 +1,70 @@ +/* + * Copyright (c) 2019 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; + +import static org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType.CONFIGURATION; + +import com.google.common.util.concurrent.FluentFuture; +import io.fd.honeycomb.translate.write.WriteContext; +import io.fd.honeycomb.translate.write.WriteFailedException; +import io.fd.honeycomb.translate.write.Writer; +import java.util.concurrent.ExecutionException; +import javax.annotation.Nonnull; +import javax.annotation.Nullable; +import org.opendaylight.controller.md.sal.binding.api.DataBroker; +import org.opendaylight.controller.md.sal.binding.api.WriteTransaction; +import org.opendaylight.mdsal.common.api.CommitInfo; +import org.opendaylight.yangtools.yang.binding.DataObject; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +/** + * Simple DataBroker backed writer allowing to delegate writes to different brokers. + */ +public final class LegacyBindingBrokerWriter implements Writer { + private final InstanceIdentifier instanceIdentifier; + private final DataBroker dataBroker; + + public LegacyBindingBrokerWriter(final InstanceIdentifier instanceIdentifier, final DataBroker dataBroker) { + this.instanceIdentifier = instanceIdentifier; + this.dataBroker = dataBroker; + } + + @Nonnull + @Override + public InstanceIdentifier getManagedDataObjectType() { + return instanceIdentifier; + } + + @Override + public void processModification(@Nonnull final InstanceIdentifier id, + @Nullable final DataObject dataBefore, @Nullable final DataObject dataAfter, + @Nonnull final WriteContext ctx) throws WriteFailedException { + final WriteTransaction writeTransaction = dataBroker.newWriteOnlyTransaction(); + writeTransaction.put(CONFIGURATION, (InstanceIdentifier) id, dataAfter); + final FluentFuture result = writeTransaction.commit(); + try { + result.get(); + } catch (InterruptedException | ExecutionException ex) { + throw new WriteFailedException(id, ex); + } + } + + @Override + public boolean supportsDirectUpdate() { + return false; + } +} diff --git a/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/write/TransactionWriteContext.java b/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/write/TransactionWriteContext.java index e853d8632..d97b5b715 100644 --- a/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/write/TransactionWriteContext.java +++ b/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/write/TransactionWriteContext.java @@ -18,17 +18,17 @@ package io.fd.honeycomb.translate.util.write; import static com.google.common.base.Preconditions.checkState; -import com.google.common.base.Optional; -import com.google.common.util.concurrent.CheckedFuture; +import com.google.common.util.concurrent.FluentFuture; import io.fd.honeycomb.translate.MappingContext; import io.fd.honeycomb.translate.ModificationCache; import io.fd.honeycomb.translate.write.WriteContext; import java.util.Map; +import java.util.Optional; +import java.util.concurrent.ExecutionException; import javax.annotation.Nonnull; -import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; -import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException; -import org.opendaylight.controller.md.sal.dom.api.DOMDataReadOnlyTransaction; import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer; +import org.opendaylight.mdsal.common.api.LogicalDatastoreType; +import org.opendaylight.mdsal.dom.api.DOMDataTreeReadTransaction; import org.opendaylight.yangtools.yang.binding.DataObject; import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier; @@ -39,15 +39,15 @@ import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode; */ public final class TransactionWriteContext implements WriteContext { - private final DOMDataReadOnlyTransaction beforeTx; - private final DOMDataReadOnlyTransaction afterTx; + private final DOMDataTreeReadTransaction beforeTx; + private final DOMDataTreeReadTransaction afterTx; private final ModificationCache ctx; private final BindingNormalizedNodeSerializer serializer; private final MappingContext mappingContext; public TransactionWriteContext(final BindingNormalizedNodeSerializer serializer, - final DOMDataReadOnlyTransaction beforeTx, - final DOMDataReadOnlyTransaction afterTx, + final DOMDataTreeReadTransaction beforeTx, + final DOMDataTreeReadTransaction afterTx, final MappingContext mappingContext) { this.serializer = serializer; this.beforeTx = beforeTx; @@ -70,18 +70,17 @@ public final class TransactionWriteContext implements WriteContext { private Optional read(final InstanceIdentifier currentId, - final DOMDataReadOnlyTransaction tx) { + final DOMDataTreeReadTransaction tx) { final YangInstanceIdentifier path = serializer.toYangInstanceIdentifier(currentId); - final CheckedFuture>, ReadFailedException> read = - tx.read(LogicalDatastoreType.CONFIGURATION, path); + final FluentFuture>> read = tx.read(LogicalDatastoreType.CONFIGURATION, path); try { // TODO HONEYCOMB-169 once the APIs are asynchronous use just Futures.transform - final Optional> optional = read.checkedGet(); + final Optional> optional = read.get(); if (!optional.isPresent()) { - return Optional.absent(); + return Optional.empty(); } final NormalizedNode data = optional.get(); @@ -91,7 +90,7 @@ public final class TransactionWriteContext implements WriteContext { checkState(targetType.isAssignableFrom(entry.getValue().getClass()), "Unexpected data object type, should be: %s, but was: %s", targetType, entry.getValue().getClass()); return Optional.of(targetType.cast(entry.getValue())); - } catch (ReadFailedException e) { + } catch (InterruptedException | ExecutionException e) { throw new IllegalStateException("Unable to perform read", e); } } diff --git a/infra/translate-utils/src/test/java/io/fd/honeycomb/translate/impl/write/util/TransactionWriteContextTest.java b/infra/translate-utils/src/test/java/io/fd/honeycomb/translate/impl/write/util/TransactionWriteContextTest.java index cbf509827..f74a0a41a 100644 --- a/infra/translate-utils/src/test/java/io/fd/honeycomb/translate/impl/write/util/TransactionWriteContextTest.java +++ b/infra/translate-utils/src/test/java/io/fd/honeycomb/translate/impl/write/util/TransactionWriteContextTest.java @@ -27,20 +27,20 @@ import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; import static org.mockito.MockitoAnnotations.initMocks; -import com.google.common.base.Optional; -import com.google.common.util.concurrent.Futures; import io.fd.honeycomb.translate.MappingContext; import io.fd.honeycomb.translate.ModificationCache; import io.fd.honeycomb.translate.util.DataObjects; import io.fd.honeycomb.translate.util.write.TransactionWriteContext; import java.util.Map; +import java.util.Optional; import org.junit.Before; import org.junit.Test; import org.mockito.Mock; -import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; -import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException; -import org.opendaylight.controller.md.sal.dom.api.DOMDataReadOnlyTransaction; import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer; +import org.opendaylight.mdsal.common.api.LogicalDatastoreType; +import org.opendaylight.mdsal.common.api.ReadFailedException; +import org.opendaylight.mdsal.dom.api.DOMDataTreeReadTransaction; +import org.opendaylight.yangtools.util.concurrent.FluentFutures; import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; import org.opendaylight.yangtools.yang.common.QName; import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier; @@ -51,9 +51,9 @@ public class TransactionWriteContextTest { @Mock private BindingNormalizedNodeSerializer serializer; @Mock - private DOMDataReadOnlyTransaction beforeTx; + private DOMDataTreeReadTransaction beforeTx; @Mock - private DOMDataReadOnlyTransaction afterTx; + private DOMDataTreeReadTransaction afterTx; @Mock private Map.Entry entry; @Mock @@ -73,7 +73,7 @@ public class TransactionWriteContextTest { @Test public void testReadBeforeNoData() throws Exception { when(beforeTx.read(eq(LogicalDatastoreType.CONFIGURATION), any(YangInstanceIdentifier.class))).thenReturn( - Futures.immediateCheckedFuture(Optional.absent())); + FluentFutures.immediateFluentFuture(Optional.empty())); final InstanceIdentifier instanceId = InstanceIdentifier.create(DataObjects.DataObject1.class); @@ -89,7 +89,7 @@ public class TransactionWriteContextTest { @Test public void testReadBefore() throws Exception { when(beforeTx.read(eq(LogicalDatastoreType.CONFIGURATION), any(YangInstanceIdentifier.class))).thenReturn( - Futures.immediateCheckedFuture(Optional.of(mock(NormalizedNode.class)))); + FluentFutures.immediateFluentFuture(Optional.of(mock(NormalizedNode.class)))); final InstanceIdentifier instanceId = InstanceIdentifier.create(DataObjects.DataObject1.class); @@ -107,14 +107,14 @@ public class TransactionWriteContextTest { @Test(expected = IllegalStateException.class) public void testReadBeforeFailed() throws Exception { when(beforeTx.read(LogicalDatastoreType.CONFIGURATION, yangId)).thenReturn( - Futures.immediateFailedCheckedFuture(mock(ReadFailedException.class))); + FluentFutures.immediateFailedFluentFuture(mock(ReadFailedException.class))); transactionWriteContext.readBefore(mock(InstanceIdentifier.class)); } @Test(expected = IllegalStateException.class) public void testReadAfterFailed() throws Exception { when(afterTx.read(LogicalDatastoreType.CONFIGURATION, yangId)).thenReturn( - Futures.immediateFailedCheckedFuture(mock(ReadFailedException.class))); + FluentFutures.immediateFailedFluentFuture(mock(ReadFailedException.class))); transactionWriteContext.readAfter(mock(InstanceIdentifier.class)); } diff --git a/infra/translate-utils/src/test/java/io/fd/honeycomb/translate/util/RealtimeMappingContextTest.java b/infra/translate-utils/src/test/java/io/fd/honeycomb/translate/util/RealtimeMappingContextTest.java index d6da2f368..d922d1454 100644 --- a/infra/translate-utils/src/test/java/io/fd/honeycomb/translate/util/RealtimeMappingContextTest.java +++ b/infra/translate-utils/src/test/java/io/fd/honeycomb/translate/util/RealtimeMappingContextTest.java @@ -21,19 +21,18 @@ import static org.junit.Assert.assertSame; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; -import com.google.common.base.Optional; -import com.google.common.util.concurrent.CheckedFuture; -import com.google.common.util.concurrent.Futures; +import com.google.common.util.concurrent.FluentFuture; +import java.util.Optional; import org.junit.Before; import org.junit.Test; import org.mockito.Mock; import org.mockito.MockitoAnnotations; -import org.opendaylight.controller.md.sal.binding.api.DataBroker; -import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction; -import org.opendaylight.controller.md.sal.binding.api.WriteTransaction; -import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; -import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException; -import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException; +import org.opendaylight.mdsal.binding.api.DataBroker; +import org.opendaylight.mdsal.binding.api.ReadTransaction; +import org.opendaylight.mdsal.binding.api.WriteTransaction; +import org.opendaylight.mdsal.common.api.LogicalDatastoreType; +import org.opendaylight.mdsal.common.api.TransactionCommitFailedException; +import org.opendaylight.yangtools.util.concurrent.FluentFutures; import org.opendaylight.yangtools.yang.binding.DataObject; import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; @@ -44,7 +43,7 @@ public class RealtimeMappingContextTest { private RealtimeMappingContext ctx; private InstanceIdentifier id = InstanceIdentifier.create(DataObject.class); @Mock - private ReadOnlyTransaction readTx; + private ReadTransaction readTx; @Mock private WriteTransaction writeTx; @Mock @@ -58,59 +57,60 @@ public class RealtimeMappingContextTest { when(broker.newReadOnlyTransaction()).thenReturn(readTx); when(broker.newWriteOnlyTransaction()).thenReturn(writeTx); - when(writeTx.submit()).thenReturn(Futures.immediateCheckedFuture(null)); + when(writeTx.commit()).thenReturn(FluentFutures.immediateNullFluentFuture()); } @Test - public void testRead() throws Exception { - final CheckedFuture, ReadFailedException> futureData = - Futures.immediateCheckedFuture(Optional.of((data))); + public void testRead() { + final FluentFuture> futureData = + FluentFutures.immediateFluentFuture(Optional.of((data))); when(readTx.read(LogicalDatastoreType.OPERATIONAL, id)).thenReturn(futureData); assertSame(ctx.read(id).get(), data); verify(broker).newReadOnlyTransaction(); verify(readTx).read(LogicalDatastoreType.OPERATIONAL, id); - when(readTx.read(LogicalDatastoreType.OPERATIONAL, id)).thenReturn(Futures.immediateCheckedFuture(Optional.absent())); + when(readTx.read(LogicalDatastoreType.OPERATIONAL, id)) + .thenReturn(FluentFutures.immediateFluentFuture(Optional.empty())); assertFalse(ctx.read(id).isPresent()); } @Test - public void testMerge() throws Exception { + public void testMerge() { ctx.merge(id, data); verify(broker).newWriteOnlyTransaction(); - verify(writeTx).merge(LogicalDatastoreType.OPERATIONAL, id, data, true); + verify(writeTx).mergeParentStructureMerge(LogicalDatastoreType.OPERATIONAL, id, data); } @Test(expected = IllegalStateException.class) public void testMergeFailure() throws Exception { - when(writeTx.submit()).thenReturn(Futures.immediateFailedCheckedFuture(ex)); + when(writeTx.commit()).thenReturn(FluentFutures.immediateFailedFluentFuture(ex)); ctx.merge(id, data); } @Test - public void testPut() throws Exception { + public void testPut() { ctx.put(id, data); verify(broker).newWriteOnlyTransaction(); - verify(writeTx).put(LogicalDatastoreType.OPERATIONAL, id, data, true); + verify(writeTx).mergeParentStructurePut(LogicalDatastoreType.OPERATIONAL, id, data); } @Test(expected = IllegalStateException.class) - public void testPutFailure() throws Exception { - when(writeTx.submit()).thenReturn(Futures.immediateFailedCheckedFuture(ex)); + public void testPutFailure() { + when(writeTx.commit()).thenReturn(FluentFutures.immediateFailedFluentFuture(ex)); ctx.put(id, data); } @Test - public void testDelete() throws Exception { + public void testDelete() { ctx.delete(id); verify(broker).newWriteOnlyTransaction(); verify(writeTx).delete(LogicalDatastoreType.OPERATIONAL, id); } @Test(expected = IllegalStateException.class) - public void testDeleteFailure() throws Exception { - when(writeTx.submit()).thenReturn(Futures.immediateFailedCheckedFuture(ex)); + public void testDeleteFailure() { + when(writeTx.commit()).thenReturn(FluentFutures.immediateFailedFluentFuture(ex)); ctx.delete(id); } } \ No newline at end of file diff --git a/infra/translate-utils/src/test/java/io/fd/honeycomb/translate/util/TransactionMappingContextTest.java b/infra/translate-utils/src/test/java/io/fd/honeycomb/translate/util/TransactionMappingContextTest.java index 2dcee889a..a9747d0af 100644 --- a/infra/translate-utils/src/test/java/io/fd/honeycomb/translate/util/TransactionMappingContextTest.java +++ b/infra/translate-utils/src/test/java/io/fd/honeycomb/translate/util/TransactionMappingContextTest.java @@ -21,16 +21,16 @@ import static org.junit.Assert.assertSame; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; -import com.google.common.base.Optional; -import com.google.common.util.concurrent.CheckedFuture; -import com.google.common.util.concurrent.Futures; +import com.google.common.util.concurrent.FluentFuture; +import java.util.Optional; import org.junit.Before; import org.junit.Test; import org.mockito.Mock; import org.mockito.MockitoAnnotations; -import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction; -import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; -import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException; +import org.opendaylight.mdsal.binding.api.ReadWriteTransaction; +import org.opendaylight.mdsal.common.api.LogicalDatastoreType; +import org.opendaylight.mdsal.common.api.ReadFailedException; +import org.opendaylight.yangtools.util.concurrent.FluentFutures; import org.opendaylight.yangtools.yang.binding.DataObject; import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; @@ -49,27 +49,27 @@ public class TransactionMappingContextTest { MockitoAnnotations.initMocks(this); ctx = new TransactionMappingContext(writeTx); - when(writeTx.submit()).thenReturn(Futures.immediateCheckedFuture(null)); + when(writeTx.commit()).thenReturn(FluentFutures.immediateNullFluentFuture()); } @Test public void testRead() throws Exception { - final CheckedFuture, ReadFailedException> futureData = - Futures.immediateCheckedFuture(Optional.of((data))); + final FluentFuture> futureData = FluentFutures.immediateFluentFuture(Optional.of((data))); when(writeTx.read(LogicalDatastoreType.OPERATIONAL, id)).thenReturn(futureData); assertSame(ctx.read(id).get(), data); verify(writeTx).read(LogicalDatastoreType.OPERATIONAL, id); - when(writeTx.read(LogicalDatastoreType.OPERATIONAL, id)).thenReturn(Futures.immediateCheckedFuture(Optional.absent())); + when(writeTx.read(LogicalDatastoreType.OPERATIONAL, id)) + .thenReturn(FluentFutures.immediateFluentFuture(Optional.empty())); assertFalse(ctx.read(id).isPresent()); } @Test(expected = IllegalStateException.class) public void testReadFailure() throws Exception { - final CheckedFuture, ReadFailedException> futureData = - Futures.immediateFailedCheckedFuture(ex); + final FluentFuture> futureData = + FluentFutures.immediateFailedFluentFuture(ex); when(writeTx.read(LogicalDatastoreType.OPERATIONAL, id)).thenReturn(futureData); assertSame(ctx.read(id).get(), data); } diff --git a/infra/translate-utils/src/test/java/io/fd/honeycomb/translate/util/read/BindingBrokerReaderTest.java b/infra/translate-utils/src/test/java/io/fd/honeycomb/translate/util/read/BindingBrokerReaderTest.java index b6af72125..18ba1bd6a 100644 --- a/infra/translate-utils/src/test/java/io/fd/honeycomb/translate/util/read/BindingBrokerReaderTest.java +++ b/infra/translate-utils/src/test/java/io/fd/honeycomb/translate/util/read/BindingBrokerReaderTest.java @@ -23,18 +23,18 @@ import static org.mockito.Mockito.mock; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; -import com.google.common.base.Optional; -import com.google.common.util.concurrent.Futures; import io.fd.honeycomb.translate.read.ReadContext; +import java.util.Optional; import org.junit.Before; import org.junit.Test; import org.mockito.Mock; import org.mockito.MockitoAnnotations; -import org.opendaylight.controller.md.sal.binding.api.DataBroker; -import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction; -import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; -import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException; +import org.opendaylight.mdsal.binding.api.DataBroker; +import org.opendaylight.mdsal.binding.api.ReadTransaction; +import org.opendaylight.mdsal.common.api.LogicalDatastoreType; +import org.opendaylight.mdsal.common.api.ReadFailedException; import org.opendaylight.yangtools.concepts.Builder; +import org.opendaylight.yangtools.util.concurrent.FluentFutures; import org.opendaylight.yangtools.yang.binding.DataObject; import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; @@ -46,7 +46,7 @@ public class BindingBrokerReaderTest { @Mock private ReadContext ctx; @Mock - private ReadOnlyTransaction tx; + private ReadTransaction tx; @Mock private DataObject data; private BindingBrokerReader bbReader; @@ -55,7 +55,8 @@ public class BindingBrokerReaderTest { public void setUp() throws Exception { MockitoAnnotations.initMocks(this); when(broker.newReadOnlyTransaction()).thenReturn(tx); - when(tx.read(LogicalDatastoreType.CONFIGURATION, id)).thenReturn(Futures.immediateCheckedFuture(Optional.of(data))); + when(tx.read(LogicalDatastoreType.CONFIGURATION, id)) + .thenReturn(FluentFutures.immediateFluentFuture(Optional.of(data))); bbReader = new BindingBrokerReader<>(id, broker, LogicalDatastoreType.CONFIGURATION, DataObjectBuilder.class); } @@ -72,7 +73,7 @@ public class BindingBrokerReaderTest { @Test(expected = io.fd.honeycomb.translate.read.ReadFailedException.class) public void testFailedRead() throws Exception { when(tx.read(LogicalDatastoreType.CONFIGURATION, id)) - .thenReturn(Futures.immediateFailedCheckedFuture(new ReadFailedException("failing"))); + .thenReturn(FluentFutures.immediateFailedFluentFuture(new ReadFailedException("failing"))); bbReader.read(id, ctx); } diff --git a/infra/translate-utils/src/test/java/io/fd/honeycomb/translate/util/read/ReflexiveListReaderCustomizerTest.java b/infra/translate-utils/src/test/java/io/fd/honeycomb/translate/util/read/ReflexiveListReaderCustomizerTest.java index aa1d0f925..d884176f6 100644 --- a/infra/translate-utils/src/test/java/io/fd/honeycomb/translate/util/read/ReflexiveListReaderCustomizerTest.java +++ b/infra/translate-utils/src/test/java/io/fd/honeycomb/translate/util/read/ReflexiveListReaderCustomizerTest.java @@ -59,7 +59,7 @@ public class ReflexiveListReaderCustomizerTest { final TestingListObjectBuilder builder = new TestingListObjectBuilder(); final InstanceIdentifier id = (InstanceIdentifier) InstanceIdentifier.create( - Collections.singletonList(new InstanceIdentifier.IdentifiableItem<>(TestingListObject.class, keyOne))); + Collections.singletonList(InstanceIdentifier.IdentifiableItem.of(TestingListObject.class, keyOne))); customizer.readCurrentAttributes(id, builder, readContext); assertEquals(keyOne, builder.getKey()); diff --git a/infra/translate-utils/src/test/java/io/fd/honeycomb/translate/util/read/cache/DumpCacheManagerTest.java b/infra/translate-utils/src/test/java/io/fd/honeycomb/translate/util/read/cache/DumpCacheManagerTest.java index 5f9362458..e52583d2b 100644 --- a/infra/translate-utils/src/test/java/io/fd/honeycomb/translate/util/read/cache/DumpCacheManagerTest.java +++ b/infra/translate-utils/src/test/java/io/fd/honeycomb/translate/util/read/cache/DumpCacheManagerTest.java @@ -21,12 +21,12 @@ import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertTrue; import static org.mockito.Mockito.when; -import com.google.common.base.Optional; import io.fd.honeycomb.translate.ModificationCache; import io.fd.honeycomb.translate.read.ReadFailedException; import java.util.ArrayList; import java.util.List; import java.util.Objects; +import java.util.Optional; import org.junit.Before; import org.junit.Test; import org.mockito.Mock; diff --git a/infra/translate-utils/src/test/java/io/fd/honeycomb/translate/util/write/BindingBrokerWriterTest.java b/infra/translate-utils/src/test/java/io/fd/honeycomb/translate/util/write/BindingBrokerWriterTest.java index 9e09112c9..49b76ce95 100644 --- a/infra/translate-utils/src/test/java/io/fd/honeycomb/translate/util/write/BindingBrokerWriterTest.java +++ b/infra/translate-utils/src/test/java/io/fd/honeycomb/translate/util/write/BindingBrokerWriterTest.java @@ -20,16 +20,15 @@ import static org.junit.Assert.assertEquals; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; -import com.google.common.util.concurrent.Futures; import io.fd.honeycomb.translate.write.WriteContext; import org.junit.Before; import org.junit.Test; import org.mockito.Mock; import org.mockito.MockitoAnnotations; -import org.opendaylight.controller.md.sal.binding.api.DataBroker; -import org.opendaylight.controller.md.sal.binding.api.WriteTransaction; -import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; -import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException; +import org.opendaylight.mdsal.binding.api.DataBroker; +import org.opendaylight.mdsal.binding.api.WriteTransaction; +import org.opendaylight.mdsal.common.api.LogicalDatastoreType; +import org.opendaylight.yangtools.util.concurrent.FluentFutures; import org.opendaylight.yangtools.yang.binding.DataObject; import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; @@ -50,7 +49,7 @@ public class BindingBrokerWriterTest { public void setUp() throws Exception { MockitoAnnotations.initMocks(this); when(broker.newWriteOnlyTransaction()).thenReturn(tx); - when(tx.submit()).thenReturn(Futures.immediateCheckedFuture(null)); + when(tx.commit()).thenReturn(FluentFutures.immediateNullFluentFuture()); bbWriter = new BindingBrokerWriter<>(id, broker); } @@ -61,12 +60,12 @@ public class BindingBrokerWriterTest { bbWriter.processModification(id, data, data, ctx); verify(broker).newWriteOnlyTransaction(); verify(tx).put(LogicalDatastoreType.CONFIGURATION, id, data); - verify(tx).submit(); + verify(tx).commit(); } @Test(expected = io.fd.honeycomb.translate.write.WriteFailedException.class) public void testFailedWrite() throws Exception { - when(tx.submit()).thenReturn(Futures.immediateFailedCheckedFuture(new TransactionCommitFailedException("failing"))); + when(tx.commit()).thenReturn(FluentFutures.immediateFailedFluentFuture(new InterruptedException("failing"))); bbWriter.processModification(id, data, data, ctx); } } \ No newline at end of file -- cgit 1.2.3-korg