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 --- infra/data-impl/pom.xml | 5 ++ .../java/io/fd/honeycomb/data/impl/DataBroker.java | 66 +++++++++++----------- .../data/impl/ModifiableDataTreeDelegator.java | 38 +++++++------ .../data/impl/ModifiableDataTreeManager.java | 25 ++++---- .../io/fd/honeycomb/data/impl/Modification.java | 12 ++-- .../fd/honeycomb/data/impl/ModificationDiff.java | 2 +- .../honeycomb/data/impl/NormalizedNodeUpdate.java | 9 ++- .../honeycomb/data/impl/ReadOnlyTransaction.java | 28 +++++---- .../honeycomb/data/impl/ReadWriteTransaction.java | 55 +++++------------- .../data/impl/ReadableDataTreeDelegator.java | 52 ++++++++--------- .../honeycomb/data/impl/ValidableTransaction.java | 18 +++--- .../fd/honeycomb/data/impl/WriteTransaction.java | 32 +++-------- .../io/fd/honeycomb/data/impl/DataBrokerTest.java | 34 +++++------ .../impl/ModifiableDataTreeDelegatorBaseTest.java | 8 +-- .../data/impl/ModifiableDataTreeDelegatorTest.java | 11 ++-- .../data/impl/ReadOnlyTransactionTest.java | 12 ++-- .../data/impl/ReadWriteTransactionTest.java | 18 ++---- .../data/impl/ReadableDataTreeDelegatorTest.java | 44 +++++++-------- .../honeycomb/data/impl/WriteTransactionTest.java | 15 ++--- 19 files changed, 212 insertions(+), 272 deletions(-) (limited to 'infra/data-impl') diff --git a/infra/data-impl/pom.xml b/infra/data-impl/pom.xml index 4587ea842..ede81a1c6 100644 --- a/infra/data-impl/pom.xml +++ b/infra/data-impl/pom.xml @@ -66,6 +66,11 @@ org.opendaylight.netconf mdsal-netconf-connector + + org.apache.commons + commons-lang3 + 3.8.1 + junit diff --git a/infra/data-impl/src/main/java/io/fd/honeycomb/data/impl/DataBroker.java b/infra/data-impl/src/main/java/io/fd/honeycomb/data/impl/DataBroker.java index 1952f8778..8f20456ed 100644 --- a/infra/data-impl/src/main/java/io/fd/honeycomb/data/impl/DataBroker.java +++ b/infra/data-impl/src/main/java/io/fd/honeycomb/data/impl/DataBroker.java @@ -18,21 +18,22 @@ package io.fd.honeycomb.data.impl; import static com.google.common.base.Preconditions.checkNotNull; +import com.google.common.collect.ClassToInstanceMap; +import com.google.common.collect.ImmutableClassToInstanceMap; import io.fd.honeycomb.data.DataModification; import io.fd.honeycomb.data.ModifiableDataManager; import io.fd.honeycomb.data.ReadableDataManager; import java.io.Closeable; import java.io.IOException; -import java.util.Collections; -import java.util.Map; import javax.annotation.Nonnull; -import org.opendaylight.controller.md.sal.common.api.data.TransactionChainListener; -import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker; -import org.opendaylight.controller.md.sal.dom.api.DOMDataBrokerExtension; -import org.opendaylight.controller.md.sal.dom.api.DOMDataReadOnlyTransaction; -import org.opendaylight.controller.md.sal.dom.api.DOMDataReadWriteTransaction; -import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction; -import org.opendaylight.controller.md.sal.dom.api.DOMTransactionChain; +import org.eclipse.jdt.annotation.NonNull; +import org.opendaylight.mdsal.dom.api.DOMDataBroker; +import org.opendaylight.mdsal.dom.api.DOMDataBrokerExtension; +import org.opendaylight.mdsal.dom.api.DOMDataTreeReadTransaction; +import org.opendaylight.mdsal.dom.api.DOMDataTreeReadWriteTransaction; +import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction; +import org.opendaylight.mdsal.dom.api.DOMTransactionChain; +import org.opendaylight.mdsal.dom.api.DOMTransactionChainListener; import org.opendaylight.netconf.mdsal.connector.DOMDataTransactionValidator; import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode; import org.slf4j.Logger; @@ -57,35 +58,32 @@ public class DataBroker implements DOMDataBroker, Closeable { } @Override - public DOMDataReadOnlyTransaction newReadOnlyTransaction() { - LOG.trace("DataBroker({}).newReadOnlyTransaction()", this); - return transactionFactory.newReadOnlyTransaction(); + public DOMDataTreeReadTransaction newReadOnlyTransaction() { + LOG.trace("DataBroker({}).newReadTransaction()", this); + return transactionFactory.newReadTransaction(); } @Override - public DOMDataReadWriteTransaction newReadWriteTransaction() { + public DOMDataTreeReadWriteTransaction newReadWriteTransaction() { LOG.trace("DataBroker({}).newReadWriteTransaction()", this); return transactionFactory.newReadWriteTransaction(); } @Override - public DOMDataWriteTransaction newWriteOnlyTransaction() { - LOG.trace("DataBroker({}).newWriteOnlyTransaction()", this); - return transactionFactory.newWriteOnlyTransaction(); + public DOMDataTreeWriteTransaction newWriteOnlyTransaction() { + LOG.trace("DataBroker({}).newWriteTransaction()", this); + return transactionFactory.newWriteTransaction(); } @Override - public DOMTransactionChain createTransactionChain(final TransactionChainListener listener) { + public DOMTransactionChain createTransactionChain(final DOMTransactionChainListener listener) { throw new UnsupportedOperationException("Not supported"); } - @Nonnull @Override - public Map, DOMDataBrokerExtension> getSupportedExtensions() { - return Collections.singletonMap( - DOMDataTransactionValidator.class, - (DOMDataTransactionValidator) tx -> ((ValidableTransaction)tx).validate() - ); + public @NonNull ClassToInstanceMap getExtensions() { + return ImmutableClassToInstanceMap.of(DOMDataTransactionValidator.class, + tx -> ((ValidableTransaction) tx).validate()); } /** @@ -118,11 +116,11 @@ public class DataBroker implements DOMDataBroker, Closeable { */ public interface TransactionFactory { - DOMDataReadOnlyTransaction newReadOnlyTransaction(); + DOMDataTreeReadTransaction newReadTransaction(); - DOMDataReadWriteTransaction newReadWriteTransaction(); + DOMDataTreeReadWriteTransaction newReadWriteTransaction(); - DOMDataWriteTransaction newWriteOnlyTransaction(); + DOMDataTreeWriteTransaction newWriteTransaction(); } /** @@ -139,12 +137,12 @@ public class DataBroker implements DOMDataBroker, Closeable { } @Override - public DOMDataReadOnlyTransaction newReadOnlyTransaction() { + public DOMDataTreeReadTransaction newReadTransaction() { return ReadOnlyTransaction.create(configDataTree.newModification(), operationalDataTree); } @Override - public DOMDataReadWriteTransaction newReadWriteTransaction() { + public DOMDataTreeReadWriteTransaction newReadWriteTransaction() { final DataModification configModification = configDataTree.newModification(); return new ReadWriteTransaction( ReadOnlyTransaction.create(configModification, operationalDataTree), @@ -152,7 +150,7 @@ public class DataBroker implements DOMDataBroker, Closeable { } @Override - public DOMDataWriteTransaction newWriteOnlyTransaction() { + public DOMDataTreeWriteTransaction newWriteTransaction() { return WriteTransaction.createConfigOnly(configDataTree.newModification()); } } @@ -168,20 +166,20 @@ public class DataBroker implements DOMDataBroker, Closeable { } @Override - public DOMDataReadOnlyTransaction newReadOnlyTransaction() { + public DOMDataTreeReadTransaction newReadTransaction() { return ReadOnlyTransaction.createOperationalOnly(operationalDataTree); } @Override - public DOMDataReadWriteTransaction newReadWriteTransaction() { + public DOMDataTreeReadWriteTransaction newReadWriteTransaction() { final DataModification dataModification = operationalDataTree.newModification(); return new ReadWriteTransaction( - ReadOnlyTransaction.createOperationalOnly(dataModification), - WriteTransaction.createOperationalOnly(dataModification)); + ReadOnlyTransaction.createOperationalOnly(dataModification), + WriteTransaction.createOperationalOnly(dataModification)); } @Override - public DOMDataWriteTransaction newWriteOnlyTransaction() { + public DOMDataTreeWriteTransaction newWriteTransaction() { return WriteTransaction.createOperationalOnly(operationalDataTree.newModification()); } } diff --git a/infra/data-impl/src/main/java/io/fd/honeycomb/data/impl/ModifiableDataTreeDelegator.java b/infra/data-impl/src/main/java/io/fd/honeycomb/data/impl/ModifiableDataTreeDelegator.java index b9246f3c4..094e621eb 100644 --- a/infra/data-impl/src/main/java/io/fd/honeycomb/data/impl/ModifiableDataTreeDelegator.java +++ b/infra/data-impl/src/main/java/io/fd/honeycomb/data/impl/ModifiableDataTreeDelegator.java @@ -17,15 +17,13 @@ package io.fd.honeycomb.data.impl; import static com.google.common.base.Preconditions.checkNotNull; -import static com.google.common.util.concurrent.Futures.immediateCheckedFuture; import static io.fd.honeycomb.data.impl.ModifiableDataTreeDelegator.DataTreeWriteContextFactory.DataTreeWriteContext; import static io.fd.honeycomb.data.impl.ModifiableDataTreeManager.DataTreeContextFactory.DataTreeContext; import com.google.common.annotations.VisibleForTesting; -import com.google.common.base.Optional; import com.google.common.collect.HashMultimap; import com.google.common.collect.Multimap; -import com.google.common.util.concurrent.CheckedFuture; +import com.google.common.util.concurrent.FluentFuture; import io.fd.honeycomb.data.DataModification; import io.fd.honeycomb.data.ReadableDataManager; import io.fd.honeycomb.translate.MappingContext; @@ -41,14 +39,17 @@ import io.fd.honeycomb.translate.write.registry.WriterRegistry; import io.fd.honeycomb.translate.write.registry.WriterRegistry.DataObjectUpdates; import java.util.List; import java.util.Map; +import java.util.Optional; import java.util.Set; +import java.util.concurrent.ExecutionException; import java.util.stream.Collectors; import javax.annotation.Nonnull; import javax.annotation.Nullable; -import org.opendaylight.controller.md.sal.binding.api.DataBroker; -import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException; -import org.opendaylight.controller.md.sal.dom.api.DOMDataReadOnlyTransaction; +import org.opendaylight.mdsal.binding.api.DataBroker; import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer; +import org.opendaylight.mdsal.common.api.CommitInfo; +import org.opendaylight.mdsal.dom.api.DOMDataTreeReadTransaction; +import org.opendaylight.yangtools.util.concurrent.FluentFutures; import org.opendaylight.yangtools.yang.binding.DataObject; import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier; @@ -67,7 +68,8 @@ import org.slf4j.LoggerFactory; public final class ModifiableDataTreeDelegator extends ModifiableDataTreeManager { private static final Logger LOG = LoggerFactory.getLogger(ModifiableDataTreeDelegator.class); - private static final ReadableDataManager EMPTY_OPERATIONAL = p -> immediateCheckedFuture(Optional.absent()); + private static final ReadableDataManager EMPTY_OPERATIONAL = + p -> FluentFutures.immediateFluentFuture(Optional.empty()); private final WriterRegistry writerRegistry; private final DataBroker contextBroker; @@ -163,10 +165,10 @@ public final class ModifiableDataTreeDelegator extends ModifiableDataTreeManager try { writerRegistry.processModifications(baUpdates, ctx); - final CheckedFuture contextUpdateResult = - ((TransactionMappingContext) mappingContext).submit(); + final FluentFuture contextUpdateResult = + ((TransactionMappingContext) mappingContext).commit(); // Blocking on context data update - contextUpdateResult.checkedGet(); + contextUpdateResult.get(); } catch (UpdateFailedException e) { // TODO - HONEYCOMB-411 LOG.warn("Failed to apply all changes", e); @@ -192,11 +194,11 @@ public final class ModifiableDataTreeDelegator extends ModifiableDataTreeManager // not passing the cause,its logged above and it would be logged after transaction // ended again(prevent double logging of same error throw new Reverter.RevertSuccessException(getNonProcessedNodes(baUpdates, processed)); - } catch (TransactionCommitFailedException e) { + } catch (InterruptedException | ExecutionException ex) { // TODO HONEYCOMB-162 revert should probably occur when context is not written successfully final String msg = "Error while updating mapping context data"; - LOG.error(msg, e); - throw new TranslationException(msg, e); + LOG.error(msg, ex); + throw new TranslationException(msg, ex); } finally { // Using finally instead of try-with-resources in order to leave ctx open for BulkUpdateException catch // block. The context is needed there, but try-with-resources closes the resource before handling ex. @@ -218,9 +220,10 @@ public final class ModifiableDataTreeDelegator extends ModifiableDataTreeManager @SuppressWarnings("squid:S2095") private TransactionWriteContext getRevertTransactionContext(final MappingContext affectedMappingContext) { // Before Tx == after partial update - final DOMDataReadOnlyTransaction beforeTx = ReadOnlyTransaction.create(this, EMPTY_OPERATIONAL); + final DOMDataTreeReadTransaction beforeTx = ReadOnlyTransaction.create(this, EMPTY_OPERATIONAL); // After Tx == before partial update - final DOMDataReadOnlyTransaction afterTx = ReadOnlyTransaction.create(untouchedModification, EMPTY_OPERATIONAL); + final DOMDataTreeReadTransaction afterTx = + ReadOnlyTransaction.create(untouchedModification, EMPTY_OPERATIONAL); return new TransactionWriteContext(serializer, beforeTx, afterTx, affectedMappingContext); } @@ -229,9 +232,10 @@ public final class ModifiableDataTreeDelegator extends ModifiableDataTreeManager @SuppressWarnings("squid:S2095") private TransactionWriteContext getTransactionWriteContext() { // Before Tx must use modification - final DOMDataReadOnlyTransaction beforeTx = ReadOnlyTransaction.create(untouchedModification, EMPTY_OPERATIONAL); + final DOMDataTreeReadTransaction + beforeTx = ReadOnlyTransaction.create(untouchedModification, EMPTY_OPERATIONAL); // After Tx must use current modification - final DOMDataReadOnlyTransaction afterTx = ReadOnlyTransaction.create(this, EMPTY_OPERATIONAL); + final DOMDataTreeReadTransaction afterTx = ReadOnlyTransaction.create(this, EMPTY_OPERATIONAL); final TransactionMappingContext mappingContext = new TransactionMappingContext( contextBroker.newReadWriteTransaction()); return new TransactionWriteContext(serializer, beforeTx, afterTx, mappingContext); diff --git a/infra/data-impl/src/main/java/io/fd/honeycomb/data/impl/ModifiableDataTreeManager.java b/infra/data-impl/src/main/java/io/fd/honeycomb/data/impl/ModifiableDataTreeManager.java index 4fa517c6e..f75ee64f5 100644 --- a/infra/data-impl/src/main/java/io/fd/honeycomb/data/impl/ModifiableDataTreeManager.java +++ b/infra/data-impl/src/main/java/io/fd/honeycomb/data/impl/ModifiableDataTreeManager.java @@ -18,19 +18,18 @@ package io.fd.honeycomb.data.impl; import static com.google.common.base.Preconditions.checkNotNull; import static com.google.common.base.Preconditions.checkState; -import static com.google.common.util.concurrent.Futures.immediateCheckedFuture; import static io.fd.honeycomb.data.impl.ModifiableDataTreeManager.DataTreeContextFactory.DataTreeContext; -import com.google.common.base.Optional; -import com.google.common.util.concurrent.CheckedFuture; +import com.google.common.util.concurrent.FluentFuture; import io.fd.honeycomb.data.DataModification; import io.fd.honeycomb.data.ModifiableDataManager; -import io.fd.honeycomb.translate.ValidationFailedException; import io.fd.honeycomb.translate.TranslationException; +import io.fd.honeycomb.translate.ValidationFailedException; +import java.util.Optional; import javax.annotation.Nonnull; import org.apache.commons.lang3.builder.RecursiveToStringStyle; import org.apache.commons.lang3.builder.ReflectionToStringBuilder; -import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException; +import org.opendaylight.yangtools.util.concurrent.FluentFutures; import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier; import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode; import org.opendaylight.yangtools.yang.data.api.schema.tree.CursorAwareDataTreeModification; @@ -69,7 +68,7 @@ public class ModifiableDataTreeManager implements ModifiableDataManager { } @Override - public final CheckedFuture>, ReadFailedException> read(@Nonnull final YangInstanceIdentifier path) { + public final FluentFuture>> read(@Nonnull final YangInstanceIdentifier path) { return newModification().read(path); } @@ -83,14 +82,12 @@ public class ModifiableDataTreeManager implements ModifiableDataManager { } @Override - public CheckedFuture>, ReadFailedException> read( - @Nonnull final YangInstanceIdentifier path) { - // TODO(HONEYCOMB-192): switch to java.util.Optional when rest of ODL infra does - final Optional> node = Optional.fromNullable(modification.readNode(path).orElse(null)); + public FluentFuture>> read(@Nonnull final YangInstanceIdentifier path) { + final Optional> node = modification.readNode(path); if (LOG.isTraceEnabled() && node.isPresent()) { LOG.trace("ConfigSnapshot.read: {}", node.get()); } - return immediateCheckedFuture(node); + return FluentFutures.immediateFluentFuture(node); } @Override @@ -145,9 +142,9 @@ public class ModifiableDataTreeManager implements ModifiableDataManager { // Sealed modification cannot be altered, so create copy. final CursorAwareDataTreeModification modificationCopy = (CursorAwareDataTreeModification) snapshot.newModification(); - final DataTreeModificationCursor cursor = modificationCopy.createCursor(dataTree.getRootPath()); - checkState(cursor != null, "DataTreeModificationCursor for root path should not be null"); - modification.applyToCursor(cursor); + Optional cursor = modificationCopy.openCursor(dataTree.getRootPath()); + checkState(cursor.isPresent(), "DataTreeModificationCursor for root path should not be empty"); + modification.applyToCursor(cursor.get()); // Then validate it. validateCandidate(prepareCandidateContext(modificationCopy)); } diff --git a/infra/data-impl/src/main/java/io/fd/honeycomb/data/impl/Modification.java b/infra/data-impl/src/main/java/io/fd/honeycomb/data/impl/Modification.java index b95fc981d..358548ee4 100644 --- a/infra/data-impl/src/main/java/io/fd/honeycomb/data/impl/Modification.java +++ b/infra/data-impl/src/main/java/io/fd/honeycomb/data/impl/Modification.java @@ -88,14 +88,12 @@ final class Modification { return dataCandidate.getModificationType(); } - com.google.common.base.Optional> getDataBefore() { - // TODO(HONEYCOMB-192): switch to java.util.Optional when rest of ODL infra does - return com.google.common.base.Optional.fromNullable(dataCandidate.getDataBefore().orElse(null)); + Optional> getDataBefore() { + return dataCandidate.getDataBefore(); } - com.google.common.base.Optional> getDataAfter() { - // TODO(HONEYCOMB-192): switch to java.util.Optional when rest of ODL infra does - return com.google.common.base.Optional.fromNullable(dataCandidate.getDataAfter().orElse(null)); + Optional> getDataAfter() { + return dataCandidate.getDataAfter(); } Object getSchemaNode() { @@ -216,7 +214,7 @@ final class Modification { ((SchemaNode) schemaNode).getQName().equals(identifier.getNodeType())) { found = schemaNode; } else { - found = ((DataNodeContainer) schemaNode).getDataChildByName(identifier.getNodeType()); + found = ((DataNodeContainer) schemaNode).findDataChildByName(identifier.getNodeType()).orElse(null); } } else if (schemaNode instanceof ChoiceSchemaNode) { // For choices, iterate through all the cases diff --git a/infra/data-impl/src/main/java/io/fd/honeycomb/data/impl/ModificationDiff.java b/infra/data-impl/src/main/java/io/fd/honeycomb/data/impl/ModificationDiff.java index 210408e39..b6adabdcc 100644 --- a/infra/data-impl/src/main/java/io/fd/honeycomb/data/impl/ModificationDiff.java +++ b/infra/data-impl/src/main/java/io/fd/honeycomb/data/impl/ModificationDiff.java @@ -135,7 +135,7 @@ final class ModificationDiff { private ModificationDiff detectUnderDisappearedNonPresenceContainer( @Nonnull final Modification modification) { - final com.google.common.base.Optional> dataBefore = modification.getDataBefore(); + final java.util.Optional> dataBefore = modification.getDataBefore(); // is disappear case if (dataBefore.isPresent()) { diff --git a/infra/data-impl/src/main/java/io/fd/honeycomb/data/impl/NormalizedNodeUpdate.java b/infra/data-impl/src/main/java/io/fd/honeycomb/data/impl/NormalizedNodeUpdate.java index bfc8a1e2c..86e312834 100644 --- a/infra/data-impl/src/main/java/io/fd/honeycomb/data/impl/NormalizedNodeUpdate.java +++ b/infra/data-impl/src/main/java/io/fd/honeycomb/data/impl/NormalizedNodeUpdate.java @@ -19,6 +19,7 @@ package io.fd.honeycomb.data.impl; import static com.google.common.base.Preconditions.checkArgument; import static com.google.common.base.Preconditions.checkNotNull; +import java.util.Optional; import javax.annotation.Nonnull; import javax.annotation.Nullable; import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier; @@ -60,13 +61,11 @@ final class NormalizedNodeUpdate { } static NormalizedNodeUpdate create(@Nonnull final Modification modification) { - final com.google.common.base.Optional> beforeData = - modification.getDataBefore(); - final com.google.common.base.Optional> afterData = - modification.getDataAfter(); + final Optional> beforeData = modification.getDataBefore(); + final Optional> afterData = modification.getDataAfter(); checkArgument(beforeData.isPresent() || afterData.isPresent(), "Both before and after data are null for %s", modification.getId()); - return NormalizedNodeUpdate.create(modification.getId(), beforeData.orNull(), afterData.orNull()); + return NormalizedNodeUpdate.create(modification.getId(), beforeData.orElse(null), afterData.orElse(null)); } static NormalizedNodeUpdate create(@Nonnull final YangInstanceIdentifier id, diff --git a/infra/data-impl/src/main/java/io/fd/honeycomb/data/impl/ReadOnlyTransaction.java b/infra/data-impl/src/main/java/io/fd/honeycomb/data/impl/ReadOnlyTransaction.java index dcd456a27..ed401eef9 100644 --- a/infra/data-impl/src/main/java/io/fd/honeycomb/data/impl/ReadOnlyTransaction.java +++ b/infra/data-impl/src/main/java/io/fd/honeycomb/data/impl/ReadOnlyTransaction.java @@ -21,23 +21,23 @@ import static com.google.common.base.Preconditions.checkState; import static java.util.Objects.requireNonNull; import com.google.common.base.Function; -import com.google.common.base.Optional; -import com.google.common.util.concurrent.CheckedFuture; +import com.google.common.util.concurrent.FluentFuture; import com.google.common.util.concurrent.Futures; import com.google.common.util.concurrent.ListenableFuture; +import com.google.common.util.concurrent.MoreExecutors; import io.fd.honeycomb.data.DataModification; import io.fd.honeycomb.data.ReadableDataManager; +import java.util.Optional; import javax.annotation.Nonnull; import javax.annotation.Nullable; -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.common.api.LogicalDatastoreType; +import org.opendaylight.mdsal.dom.api.DOMDataTreeReadTransaction; import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier; import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -final class ReadOnlyTransaction implements DOMDataReadOnlyTransaction { +final class ReadOnlyTransaction implements DOMDataTreeReadTransaction { private static final Logger LOG = LoggerFactory.getLogger(ReadOnlyTransaction.class); @@ -70,9 +70,8 @@ final class ReadOnlyTransaction implements DOMDataReadOnlyTransaction { } @Override - public synchronized CheckedFuture>, ReadFailedException> read( - final LogicalDatastoreType store, - final YangInstanceIdentifier path) { + public synchronized FluentFuture>> read(final LogicalDatastoreType store, + final YangInstanceIdentifier path) { LOG.debug("ReadOnlyTransaction.read(), store={}, path={}", store, path); checkState(!closed, "Transaction has been closed"); @@ -86,12 +85,13 @@ final class ReadOnlyTransaction implements DOMDataReadOnlyTransaction { } @Override - public CheckedFuture exists(final LogicalDatastoreType store, - final YangInstanceIdentifier path) { + public FluentFuture exists(final LogicalDatastoreType store, + final YangInstanceIdentifier path) { LOG.debug("ReadOnlyTransaction.exists() store={}, path={}", store, path); - ListenableFuture listenableFuture = Futures.transform(read(store, path), IS_NODE_PRESENT); - return Futures.makeChecked(listenableFuture, ANY_EX_TO_READ_FAILED_EXCEPTION_MAPPER); + ListenableFuture listenableFuture = Futures.transform(read(store, path), IS_NODE_PRESENT, + MoreExecutors.directExecutor()); + return FluentFuture.from(listenableFuture); } @Nonnull @@ -119,6 +119,4 @@ final class ReadOnlyTransaction implements DOMDataReadOnlyTransaction { private static final Function>, ? extends Boolean> IS_NODE_PRESENT = (Function>, Boolean>) input -> input == null ? Boolean.FALSE : input.isPresent(); - private static final Function ANY_EX_TO_READ_FAILED_EXCEPTION_MAPPER = - (Function) e -> new ReadFailedException("Exists failed", e); } \ No newline at end of file diff --git a/infra/data-impl/src/main/java/io/fd/honeycomb/data/impl/ReadWriteTransaction.java b/infra/data-impl/src/main/java/io/fd/honeycomb/data/impl/ReadWriteTransaction.java index c7d54f0ec..b2e7d38e1 100644 --- a/infra/data-impl/src/main/java/io/fd/honeycomb/data/impl/ReadWriteTransaction.java +++ b/infra/data-impl/src/main/java/io/fd/honeycomb/data/impl/ReadWriteTransaction.java @@ -16,39 +16,28 @@ package io.fd.honeycomb.data.impl; -import com.google.common.base.Optional; import com.google.common.base.Preconditions; -import com.google.common.util.concurrent.CheckedFuture; import com.google.common.util.concurrent.FluentFuture; +import java.util.Optional; import javax.annotation.Nonnull; -import org.apache.commons.lang3.builder.RecursiveToStringStyle; -import org.apache.commons.lang3.builder.ReflectionToStringBuilder; -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.controller.md.sal.dom.api.DOMDataReadOnlyTransaction; -import org.opendaylight.controller.md.sal.dom.api.DOMDataReadTransaction; -import org.opendaylight.controller.md.sal.dom.api.DOMDataReadWriteTransaction; -import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction; import org.opendaylight.mdsal.common.api.CommitInfo; -import org.opendaylight.netconf.mdsal.connector.DOMDataTransactionValidator; +import org.opendaylight.mdsal.common.api.LogicalDatastoreType; +import org.opendaylight.mdsal.dom.api.DOMDataTreeReadTransaction; +import org.opendaylight.mdsal.dom.api.DOMDataTreeReadWriteTransaction; +import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction; import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier; import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; /** - * Composite DOM transaction that delegates reads to a {@link DOMDataReadTransaction} delegate and writes to a {@link - * DOMDataWriteTransaction} delegate. + * Composite DOM transaction that delegates reads to a {@link DOMDataTreeReadTransaction} delegate and writes to a {@link + * DOMDataTreeWriteTransaction} delegate. */ -final class ReadWriteTransaction implements DOMDataReadWriteTransaction, ValidableTransaction { +final class ReadWriteTransaction implements DOMDataTreeReadWriteTransaction, ValidableTransaction { - private static final Logger LOG = LoggerFactory.getLogger(ReadWriteTransaction.class); - - private final DOMDataReadOnlyTransaction delegateReadTx; + private final DOMDataTreeReadTransaction delegateReadTx; private final ValidableTransaction delegateWriteTx; - ReadWriteTransaction(@Nonnull final DOMDataReadOnlyTransaction delegateReadTx, + ReadWriteTransaction(@Nonnull final DOMDataTreeReadTransaction delegateReadTx, @Nonnull final ValidableTransaction delegateWriteTx) { this.delegateReadTx = Preconditions.checkNotNull(delegateReadTx, "delegateReadTx should not be null"); this.delegateWriteTx = Preconditions.checkNotNull(delegateWriteTx, "delegateWriteTx should not be null"); @@ -77,34 +66,20 @@ final class ReadWriteTransaction implements DOMDataReadWriteTransaction, Validab delegateWriteTx.delete(store, path); } - @Override - public CheckedFuture submit() { - //TODO - remove after https://bugs.opendaylight.org/show_bug.cgi?id=7791 resolved - if (LOG.isDebugEnabled()) { - LOG.debug("Submitting transaction {}", ReflectionToStringBuilder.toString( - delegateWriteTx, - RecursiveToStringStyle.MULTI_LINE_STYLE, - false, - false - )); - } - return delegateWriteTx.submit(); - } - @Override public FluentFuture commit() { return delegateWriteTx.commit(); } @Override - public CheckedFuture>, ReadFailedException> read(final LogicalDatastoreType store, - final YangInstanceIdentifier path) { + public FluentFuture>> read(final LogicalDatastoreType store, + final YangInstanceIdentifier path) { return delegateReadTx.read(store, path); } @Override - public CheckedFuture exists(final LogicalDatastoreType store, - final YangInstanceIdentifier path) { + public FluentFuture exists(final LogicalDatastoreType store, + final YangInstanceIdentifier path) { return delegateReadTx.exists(store, path); } @@ -114,7 +89,7 @@ final class ReadWriteTransaction implements DOMDataReadWriteTransaction, Validab } @Override - public CheckedFuture validate() { + public FluentFuture validate() { return delegateWriteTx.validate(); } } diff --git a/infra/data-impl/src/main/java/io/fd/honeycomb/data/impl/ReadableDataTreeDelegator.java b/infra/data-impl/src/main/java/io/fd/honeycomb/data/impl/ReadableDataTreeDelegator.java index de3cabde7..79188188e 100644 --- a/infra/data-impl/src/main/java/io/fd/honeycomb/data/impl/ReadableDataTreeDelegator.java +++ b/infra/data-impl/src/main/java/io/fd/honeycomb/data/impl/ReadableDataTreeDelegator.java @@ -21,12 +21,10 @@ import static com.google.common.collect.Iterables.getOnlyElement; import com.google.common.annotations.VisibleForTesting; import com.google.common.base.Function; -import com.google.common.base.Optional; import com.google.common.base.Preconditions; import com.google.common.collect.Collections2; import com.google.common.collect.Multimap; -import com.google.common.util.concurrent.CheckedFuture; -import com.google.common.util.concurrent.Futures; +import com.google.common.util.concurrent.FluentFuture; import io.fd.honeycomb.data.ReadableDataManager; import io.fd.honeycomb.translate.MappingContext; import io.fd.honeycomb.translate.ModificationCache; @@ -36,9 +34,12 @@ import io.fd.honeycomb.translate.read.registry.ReaderRegistry; import io.fd.honeycomb.translate.util.TransactionMappingContext; import java.util.Collection; 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.TransactionCommitFailedException; import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer; +import org.opendaylight.mdsal.common.api.CommitInfo; +import org.opendaylight.yangtools.util.concurrent.FluentFutures; import org.opendaylight.yangtools.yang.binding.DataObject; import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier; @@ -67,7 +68,7 @@ public final class ReadableDataTreeDelegator implements ReadableDataManager { private final BindingNormalizedNodeSerializer serializer; private final ReaderRegistry readerRegistry; private final SchemaContext globalContext; - private final org.opendaylight.controller.md.sal.binding.api.DataBroker contextBroker; + private final org.opendaylight.mdsal.binding.api.DataBroker contextBroker; /** * Creates operational data tree instance. @@ -80,7 +81,7 @@ public final class ReadableDataTreeDelegator implements ReadableDataManager { public ReadableDataTreeDelegator(@Nonnull BindingNormalizedNodeSerializer serializer, @Nonnull final SchemaContext globalContext, @Nonnull final ReaderRegistry readerRegistry, - @Nonnull final org.opendaylight.controller.md.sal.binding.api.DataBroker contextBroker) { + @Nonnull final org.opendaylight.mdsal.binding.api.DataBroker contextBroker) { this.contextBroker = checkNotNull(contextBroker, "contextBroker should not be null"); this.globalContext = checkNotNull(globalContext, "globalContext should not be null"); this.serializer = checkNotNull(serializer, "serializer should not be null"); @@ -88,12 +89,12 @@ public final class ReadableDataTreeDelegator implements ReadableDataManager { } @Override - public CheckedFuture>, - org.opendaylight.controller.md.sal.common.api.data.ReadFailedException> read( + public FluentFuture>> read( @Nonnull final YangInstanceIdentifier yangInstanceIdentifier) { - try (TransactionMappingContext mappingContext = new TransactionMappingContext(contextBroker.newReadWriteTransaction()); - ReadContext ctx = new ReadContextImpl(mappingContext)) { + try (TransactionMappingContext mappingContext = new TransactionMappingContext( + contextBroker.newReadWriteTransaction()); + ReadContext ctx = new ReadContextImpl(mappingContext)) { final Optional> value; if (checkNotNull(yangInstanceIdentifier).equals(YangInstanceIdentifier.EMPTY)) { @@ -103,24 +104,17 @@ public final class ReadableDataTreeDelegator implements ReadableDataManager { } // Submit context mapping updates - final CheckedFuture contextUpdateResult = - ((TransactionMappingContext) ctx.getMappingContext()).submit(); + final FluentFuture contextUpdateResult = + ((TransactionMappingContext) ctx.getMappingContext()).commit(); // Blocking on context data update - contextUpdateResult.checkedGet(); - - return Futures.immediateCheckedFuture(value); - - } catch (ReadFailedException e) { - return Futures.immediateFailedCheckedFuture( - new org.opendaylight.controller.md.sal.common.api.data.ReadFailedException("Failed to read data", e)); - } catch (TransactionCommitFailedException e) { - // Context write failed. This should not happen, but if it does, there's not much that can be done here - // ... try to read again - final String msg = "Error while updating mapping context data"; - LOG.error(msg, e); - return Futures.immediateFailedCheckedFuture( - new org.opendaylight.controller.md.sal.common.api.data.ReadFailedException(msg, e) - ); + contextUpdateResult.get(); + + return FluentFutures.immediateFluentFuture(value); + + } catch (InterruptedException | ExecutionException | ReadFailedException ex) { + return FluentFutures.immediateFailedFluentFuture( + new org.opendaylight.controller.md.sal.common.api.data.ReadFailedException("Failed to read data", + ex)); } } @@ -138,9 +132,9 @@ public final class ReadableDataTreeDelegator implements ReadableDataManager { if (dataObject.isPresent()) { final NormalizedNode value = toNormalizedNodeFunction(path).apply(dataObject.get()); - return Optional.>fromNullable(value); + return Optional.ofNullable(value); } else { - return Optional.absent(); + return Optional.empty(); } } diff --git a/infra/data-impl/src/main/java/io/fd/honeycomb/data/impl/ValidableTransaction.java b/infra/data-impl/src/main/java/io/fd/honeycomb/data/impl/ValidableTransaction.java index 0c67f863f..09dde4e70 100644 --- a/infra/data-impl/src/main/java/io/fd/honeycomb/data/impl/ValidableTransaction.java +++ b/infra/data-impl/src/main/java/io/fd/honeycomb/data/impl/ValidableTransaction.java @@ -17,19 +17,18 @@ package io.fd.honeycomb.data.impl; import com.google.common.annotations.Beta; -import com.google.common.util.concurrent.CheckedFuture; -import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction; +import com.google.common.util.concurrent.FluentFuture; +import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction; import org.opendaylight.netconf.mdsal.connector.DOMDataTransactionValidator; -import org.opendaylight.netconf.mdsal.connector.DOMDataTransactionValidator.ValidationFailedException; /** - * An {@link DOMDataWriteTransaction} than can be validated. + * An {@link DOMDataTreeWriteTransaction} than can be validated. * @see DOMDataTransactionValidator */ @Beta -interface ValidableTransaction extends DOMDataWriteTransaction { +interface ValidableTransaction extends DOMDataTreeWriteTransaction { /** - * Validates state of the data tree associated with the provided {@link DOMDataWriteTransaction}. + * Validates state of the data tree associated with the provided {@link DOMDataTreeWriteTransaction}. * *

The operation should not have any side-effects on the transaction state. * @@ -37,9 +36,8 @@ interface ValidableTransaction extends DOMDataWriteTransaction { * if the state of the transaction has not been changed. * * @return - * a CheckedFuture containing the result of the validate operation. The future blocks until the validation - * operation is complete. A successful validate returns nothing. On failure, the Future will fail - * with a {@link ValidationFailedException} or an exception derived from ValidationFailedException. + * a FluentFuture containing the result of the validate operation. The future blocks until the validation + * operation is complete. A successful validate returns nothing. On failure, the Future will fail. */ - CheckedFuture validate(); + FluentFuture validate(); } diff --git a/infra/data-impl/src/main/java/io/fd/honeycomb/data/impl/WriteTransaction.java b/infra/data-impl/src/main/java/io/fd/honeycomb/data/impl/WriteTransaction.java index 91b48cc10..1ce7db74f 100644 --- a/infra/data-impl/src/main/java/io/fd/honeycomb/data/impl/WriteTransaction.java +++ b/infra/data-impl/src/main/java/io/fd/honeycomb/data/impl/WriteTransaction.java @@ -20,7 +20,6 @@ import static com.google.common.base.Preconditions.checkArgument; import static java.util.Objects.requireNonNull; import com.google.common.base.Preconditions; -import com.google.common.util.concurrent.CheckedFuture; import com.google.common.util.concurrent.FluentFuture; import com.google.common.util.concurrent.Futures; import io.fd.honeycomb.data.DataModification; @@ -30,10 +29,11 @@ import javax.annotation.Nonnull; import javax.annotation.Nullable; import javax.annotation.concurrent.NotThreadSafe; import org.eclipse.jdt.annotation.NonNull; -import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; -import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException; -import org.opendaylight.netconf.mdsal.connector.DOMDataTransactionValidator; import org.opendaylight.mdsal.common.api.CommitInfo; +import org.opendaylight.mdsal.common.api.LogicalDatastoreType; +import org.opendaylight.mdsal.common.api.TransactionCommitFailedException; +import org.opendaylight.netconf.mdsal.connector.DOMDataTransactionValidator; +import org.opendaylight.yangtools.util.concurrent.FluentFutures; import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier; import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode; import org.slf4j.Logger; @@ -113,23 +113,6 @@ final class WriteTransaction implements ValidableTransaction { handleOperation(store, (modification) -> modification.delete(path)); } - @Deprecated - @Override - public CheckedFuture submit() { - LOG.trace("WriteTransaction.submit()"); - checkIsNew(); - - try { - doCommit(); - } catch (Exception e) { - status = TransactionStatus.FAILED; - LOG.error("Submit failed", e); - return Futures.immediateFailedCheckedFuture( - new TransactionCommitFailedException("Failed to validate DataTreeModification", e)); - } - return Futures.immediateCheckedFuture(null); - } - private void doCommit() throws TranslationException { status = TransactionStatus.SUBMITED; if (configModification != null) { @@ -164,7 +147,7 @@ final class WriteTransaction implements ValidableTransaction { } @Override - public CheckedFuture validate() { + public FluentFuture validate() { try { if (configModification != null) { configModification.validate(); @@ -173,9 +156,10 @@ final class WriteTransaction implements ValidableTransaction { operationalModification.validate(); } } catch (Exception e) { - return Futures.immediateFailedCheckedFuture(new DOMDataTransactionValidator.ValidationFailedException(e.getMessage(), e.getCause())); + return FluentFutures.immediateFailedFluentFuture( + new DOMDataTransactionValidator.ValidationFailedException(e.getMessage(), e.getCause())); } - return Futures.immediateCheckedFuture(null); + return FluentFutures.immediateNullFluentFuture(); } diff --git a/infra/data-impl/src/test/java/io/fd/honeycomb/data/impl/DataBrokerTest.java b/infra/data-impl/src/test/java/io/fd/honeycomb/data/impl/DataBrokerTest.java index 124179c79..56d333436 100644 --- a/infra/data-impl/src/test/java/io/fd/honeycomb/data/impl/DataBrokerTest.java +++ b/infra/data-impl/src/test/java/io/fd/honeycomb/data/impl/DataBrokerTest.java @@ -24,18 +24,19 @@ import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; import static org.mockito.MockitoAnnotations.initMocks; +import com.google.common.collect.ClassToInstanceMap; import io.fd.honeycomb.data.DataModification; import io.fd.honeycomb.data.ModifiableDataManager; import io.fd.honeycomb.data.ReadableDataManager; -import java.util.Map; +import org.eclipse.jdt.annotation.NonNull; 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.TransactionChainListener; -import org.opendaylight.controller.md.sal.dom.api.DOMDataBrokerExtension; -import org.opendaylight.controller.md.sal.dom.api.DOMDataReadOnlyTransaction; -import org.opendaylight.controller.md.sal.dom.api.DOMDataReadWriteTransaction; +import org.opendaylight.mdsal.common.api.LogicalDatastoreType; +import org.opendaylight.mdsal.dom.api.DOMDataBrokerExtension; +import org.opendaylight.mdsal.dom.api.DOMDataTreeReadTransaction; +import org.opendaylight.mdsal.dom.api.DOMDataTreeReadWriteTransaction; +import org.opendaylight.mdsal.dom.api.DOMTransactionChainListener; import org.opendaylight.netconf.mdsal.connector.DOMDataTransactionValidator; import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier; @@ -58,7 +59,7 @@ public class DataBrokerTest { @Test public void testNewReadWriteTransaction() { - final DOMDataReadWriteTransaction readWriteTx = broker.newReadWriteTransaction(); + final DOMDataTreeReadWriteTransaction readWriteTx = broker.newReadWriteTransaction(); final YangInstanceIdentifier path = mock(YangInstanceIdentifier.class); readWriteTx.read(LogicalDatastoreType.CONFIGURATION, path); @@ -77,7 +78,7 @@ public class DataBrokerTest { @Test public void testNewReadOnlyTransaction() { - final DOMDataReadOnlyTransaction readTx = broker.newReadOnlyTransaction(); + final DOMDataTreeReadTransaction readTx = broker.newReadOnlyTransaction(); final YangInstanceIdentifier path = mock(YangInstanceIdentifier.class); readTx.read(LogicalDatastoreType.CONFIGURATION, path); @@ -88,14 +89,14 @@ public class DataBrokerTest { @Test(expected = UnsupportedOperationException.class) public void testCreateTransactionChain() { - final TransactionChainListener listener = mock(TransactionChainListener.class); + final DOMTransactionChainListener listener = mock(DOMTransactionChainListener.class); broker.createTransactionChain(listener); } @Test public void testGetSupportedExtensions() { - final Map, DOMDataBrokerExtension> supportedExtensions = - broker.getSupportedExtensions(); + final @NonNull ClassToInstanceMap supportedExtensions = + broker.getExtensions(); assertEquals(1, supportedExtensions.size()); assertNotNull(supportedExtensions.get(DOMDataTransactionValidator.class)); } @@ -117,7 +118,7 @@ public class DataBrokerTest { @Test public void testNewReadWriteTransaction() { - final DOMDataReadWriteTransaction readWriteTx = broker.newReadWriteTransaction(); + final DOMDataTreeReadWriteTransaction readWriteTx = broker.newReadWriteTransaction(); final YangInstanceIdentifier path = mock(YangInstanceIdentifier.class); readWriteTx.read(LogicalDatastoreType.OPERATIONAL, path); @@ -133,7 +134,7 @@ public class DataBrokerTest { @Test public void testNewReadOnlyTransaction() { - final DOMDataReadOnlyTransaction readTx = broker.newReadOnlyTransaction(); + final DOMDataTreeReadTransaction readTx = broker.newReadOnlyTransaction(); final YangInstanceIdentifier path = mock(YangInstanceIdentifier.class); readTx.read(LogicalDatastoreType.OPERATIONAL, path); @@ -143,7 +144,7 @@ public class DataBrokerTest { @Test(expected = IllegalArgumentException.class) public void testReadConfig() { - final DOMDataReadOnlyTransaction readTx = broker.newReadOnlyTransaction(); + final DOMDataTreeReadTransaction readTx = broker.newReadOnlyTransaction(); final YangInstanceIdentifier path = mock(YangInstanceIdentifier.class); readTx.read(LogicalDatastoreType.CONFIGURATION, path); @@ -151,14 +152,13 @@ public class DataBrokerTest { @Test(expected = UnsupportedOperationException.class) public void testCreateTransactionChain() { - final TransactionChainListener listener = mock(TransactionChainListener.class); + final DOMTransactionChainListener listener = mock(DOMTransactionChainListener.class); broker.createTransactionChain(listener); } @Test public void testGetSupportedExtensions() { - final Map, DOMDataBrokerExtension> supportedExtensions = - broker.getSupportedExtensions(); + final @NonNull ClassToInstanceMap supportedExtensions = broker.getExtensions(); assertTrue(supportedExtensions.isEmpty()); } } diff --git a/infra/data-impl/src/test/java/io/fd/honeycomb/data/impl/ModifiableDataTreeDelegatorBaseTest.java b/infra/data-impl/src/test/java/io/fd/honeycomb/data/impl/ModifiableDataTreeDelegatorBaseTest.java index 5690e78c3..8f686333e 100644 --- a/infra/data-impl/src/test/java/io/fd/honeycomb/data/impl/ModifiableDataTreeDelegatorBaseTest.java +++ b/infra/data-impl/src/test/java/io/fd/honeycomb/data/impl/ModifiableDataTreeDelegatorBaseTest.java @@ -21,7 +21,6 @@ import static org.mockito.Mockito.doReturn; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.when; -import com.google.common.util.concurrent.Futures; import io.fd.honeycomb.translate.write.DataObjectUpdate; import io.fd.honeycomb.translate.write.WriteContext; import io.fd.honeycomb.translate.write.registry.WriterRegistry; @@ -32,8 +31,9 @@ import org.mockito.ArgumentCaptor; import org.mockito.Captor; import org.mockito.Mock; import org.mockito.MockitoAnnotations; -import org.opendaylight.controller.md.sal.binding.api.DataBroker; +import org.opendaylight.mdsal.binding.api.DataBroker; import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer; +import org.opendaylight.yangtools.util.concurrent.FluentFutures; import org.opendaylight.yangtools.yang.binding.DataObject; import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; import org.opendaylight.yangtools.yang.common.QName; @@ -52,7 +52,7 @@ abstract class ModifiableDataTreeDelegatorBaseTest extends ModificationBaseTest @Mock DataBroker contextBroker; @Mock - org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction tx; + org.opendaylight.mdsal.binding.api.ReadWriteTransaction tx; @Captor ArgumentCaptor writeContextCaptor; @@ -72,7 +72,7 @@ abstract class ModifiableDataTreeDelegatorBaseTest extends ModificationBaseTest MockitoAnnotations.initMocks(this); dataTree = getDataTree(); when(contextBroker.newReadWriteTransaction()).thenReturn(tx); - when(tx.submit()).thenReturn(Futures.immediateCheckedFuture(null)); + when(tx.commit()).thenReturn(FluentFutures.immediateNullFluentFuture()); when(serializer.fromYangInstanceIdentifier(any(YangInstanceIdentifier.class))) .thenReturn(((InstanceIdentifier) DEFAULT_ID)); diff --git a/infra/data-impl/src/test/java/io/fd/honeycomb/data/impl/ModifiableDataTreeDelegatorTest.java b/infra/data-impl/src/test/java/io/fd/honeycomb/data/impl/ModifiableDataTreeDelegatorTest.java index b1e60c440..8ec18e4da 100644 --- a/infra/data-impl/src/test/java/io/fd/honeycomb/data/impl/ModifiableDataTreeDelegatorTest.java +++ b/infra/data-impl/src/test/java/io/fd/honeycomb/data/impl/ModifiableDataTreeDelegatorTest.java @@ -28,19 +28,18 @@ 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.HashMultimap; import com.google.common.collect.ImmutableMultimap; import com.google.common.collect.Multimap; -import com.google.common.util.concurrent.CheckedFuture; +import com.google.common.util.concurrent.FluentFuture; import io.fd.honeycomb.data.DataModification; import io.fd.honeycomb.translate.write.DataObjectUpdate; import io.fd.honeycomb.translate.write.WriteContext; import io.fd.honeycomb.translate.write.registry.WriterRegistry; import java.util.HashMap; import java.util.Map; +import java.util.Optional; import org.junit.Test; -import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException; import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; import org.opendaylight.yangtools.yang.common.QName; import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier; @@ -54,9 +53,9 @@ public class ModifiableDataTreeDelegatorTest extends ModifiableDataTreeDelegator public void testRead() throws Exception { final ContainerNode topContainer = getTopContainer("topContainer"); addNodeToTree(dataTree, topContainer, TOP_CONTAINER_ID); - final CheckedFuture>, ReadFailedException> read = + final FluentFuture>> read = configDataTree.read(TOP_CONTAINER_ID); - final CheckedFuture>, ReadFailedException> read2 = + final FluentFuture>> read2 = configDataTree.newModification().read(TOP_CONTAINER_ID); final Optional> normalizedNodeOptional = read.get(); final Optional> normalizedNodeOptional2 = read2.get(); @@ -64,7 +63,7 @@ public class ModifiableDataTreeDelegatorTest extends ModifiableDataTreeDelegator assertEquals(normalizedNodeOptional, normalizedNodeOptional2); assertTrue(normalizedNodeOptional.isPresent()); assertEquals(topContainer, normalizedNodeOptional.get()); - assertEquals(dataTree.takeSnapshot().readNode(TOP_CONTAINER_ID), Optional.toJavaUtil(normalizedNodeOptional)); + assertEquals(dataTree.takeSnapshot().readNode(TOP_CONTAINER_ID), normalizedNodeOptional); } @Test diff --git a/infra/data-impl/src/test/java/io/fd/honeycomb/data/impl/ReadOnlyTransactionTest.java b/infra/data-impl/src/test/java/io/fd/honeycomb/data/impl/ReadOnlyTransactionTest.java index 77470d17c..690a0deee 100644 --- a/infra/data-impl/src/test/java/io/fd/honeycomb/data/impl/ReadOnlyTransactionTest.java +++ b/infra/data-impl/src/test/java/io/fd/honeycomb/data/impl/ReadOnlyTransactionTest.java @@ -22,15 +22,14 @@ 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.CheckedFuture; -import io.fd.honeycomb.data.ReadableDataManager; +import com.google.common.util.concurrent.FluentFuture; import io.fd.honeycomb.data.DataModification; +import io.fd.honeycomb.data.ReadableDataManager; +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.mdsal.common.api.LogicalDatastoreType; import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier; import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode; @@ -52,8 +51,7 @@ public class ReadOnlyTransactionTest { @Test public void testExists() { final YangInstanceIdentifier path = mock(YangInstanceIdentifier.class); - final CheckedFuture>, ReadFailedException> - future = mock(CheckedFuture.class); + final FluentFuture>> future = mock(FluentFuture.class); when(operationalData.read(path)).thenReturn(future); readOnlyTx.exists(LogicalDatastoreType.OPERATIONAL, path); diff --git a/infra/data-impl/src/test/java/io/fd/honeycomb/data/impl/ReadWriteTransactionTest.java b/infra/data-impl/src/test/java/io/fd/honeycomb/data/impl/ReadWriteTransactionTest.java index bbe384289..cc744530f 100644 --- a/infra/data-impl/src/test/java/io/fd/honeycomb/data/impl/ReadWriteTransactionTest.java +++ b/infra/data-impl/src/test/java/io/fd/honeycomb/data/impl/ReadWriteTransactionTest.java @@ -23,15 +23,15 @@ import static org.mockito.MockitoAnnotations.initMocks; 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.dom.api.DOMDataReadOnlyTransaction; +import org.opendaylight.mdsal.common.api.LogicalDatastoreType; +import org.opendaylight.mdsal.dom.api.DOMDataTreeReadTransaction; import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier; import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode; public class ReadWriteTransactionTest { @Mock - private DOMDataReadOnlyTransaction readTx; + private DOMDataTreeReadTransaction readTx; @Mock private ValidableTransaction writeTx; @@ -78,15 +78,7 @@ public class ReadWriteTransactionTest { } @Test - public void testSubmit() throws Exception { - readWriteTx.submit(); - verify(writeTx).submit(); - } - - - @SuppressWarnings("deprecation") - @Test - public void testCommit() throws Exception { + public void testCommit() { readWriteTx.commit(); verify(writeTx).commit(); } @@ -104,7 +96,7 @@ public class ReadWriteTransactionTest { } @Test - public void testGetIdentifier() throws Exception { + public void testGetIdentifier() { assertNotNull(readWriteTx.getIdentifier()); } } \ No newline at end of file diff --git a/infra/data-impl/src/test/java/io/fd/honeycomb/data/impl/ReadableDataTreeDelegatorTest.java b/infra/data-impl/src/test/java/io/fd/honeycomb/data/impl/ReadableDataTreeDelegatorTest.java index 76b46dad6..6ff625d8e 100644 --- a/infra/data-impl/src/test/java/io/fd/honeycomb/data/impl/ReadableDataTreeDelegatorTest.java +++ b/infra/data-impl/src/test/java/io/fd/honeycomb/data/impl/ReadableDataTreeDelegatorTest.java @@ -30,29 +30,30 @@ 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.collect.Iterables; import com.google.common.collect.LinkedListMultimap; import com.google.common.collect.Lists; import com.google.common.collect.Multimap; -import com.google.common.util.concurrent.CheckedFuture; -import com.google.common.util.concurrent.Futures; +import com.google.common.util.concurrent.FluentFuture; import io.fd.honeycomb.translate.read.ReadContext; import io.fd.honeycomb.translate.read.registry.ReaderRegistry; import java.util.Collections; import java.util.List; import java.util.Map; +import java.util.Optional; +import java.util.concurrent.ExecutionException; import java.util.stream.Collectors; import org.junit.Before; import org.junit.Test; import org.mockito.Mock; -import org.opendaylight.controller.md.sal.binding.api.DataBroker; -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.DOMDataBroker; -import org.opendaylight.controller.md.sal.dom.api.DOMDataReadOnlyTransaction; +import org.opendaylight.mdsal.binding.api.DataBroker; import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer; +import org.opendaylight.mdsal.common.api.LogicalDatastoreType; +import org.opendaylight.mdsal.dom.api.DOMDataBroker; +import org.opendaylight.mdsal.dom.api.DOMDataTreeReadTransaction; import org.opendaylight.yangtools.util.UnmodifiableCollection; +import org.opendaylight.yangtools.util.concurrent.FluentFutures; import org.opendaylight.yangtools.yang.binding.DataObject; import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; import org.opendaylight.yangtools.yang.common.QName; @@ -87,7 +88,7 @@ public class ReadableDataTreeDelegatorTest { @Mock private DOMDataBroker netconfMonitoringBroker; @Mock - private DOMDataReadOnlyTransaction domDataReadOnlyTransaction; + private DOMDataTreeReadTransaction domDataReadOnlyTransaction; @Mock private DataBroker contextBroker; @@ -95,16 +96,16 @@ public class ReadableDataTreeDelegatorTest { public void setUp() { initMocks(this); operationalData = new ReadableDataTreeDelegator(serializer, globalContext, reader, contextBroker); - doReturn(schemaNode).when(globalContext).getDataChildByName(any(QName.class)); + doReturn(Optional.of(schemaNode)).when(globalContext).findDataChildByName(any(QName.class)); doReturn(domDataReadOnlyTransaction).when(netconfMonitoringBroker).newReadOnlyTransaction(); - doReturn(Futures.immediateCheckedFuture(Optional.absent())).when(domDataReadOnlyTransaction) + doReturn(FluentFutures.immediateFluentFuture(Optional.empty())).when(domDataReadOnlyTransaction) .read(any(LogicalDatastoreType.class), any(YangInstanceIdentifier.class)); - final org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction ctxTransaction = mock( - org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction.class); + final org.opendaylight.mdsal.binding.api.ReadWriteTransaction ctxTransaction = mock( + org.opendaylight.mdsal.binding.api.ReadWriteTransaction.class); doReturn(ctxTransaction).when(contextBroker).newReadWriteTransaction(); - doReturn(Futures.immediateCheckedFuture(null)).when(ctxTransaction).submit(); + doReturn(FluentFutures.immediateNullFluentFuture()).when(ctxTransaction).commit(); } @Test @@ -124,7 +125,7 @@ public class ReadableDataTreeDelegatorTest { final DataContainerChild expectedValue = mock(DataContainerChild.class); doReturn(expectedValue).when(entry).getValue(); - final CheckedFuture>, ReadFailedException> future = operationalData.read(yangId); + final FluentFuture>> future = operationalData.read(yangId); verify(serializer).fromYangInstanceIdentifier(yangId); verify(reader).read(same(id), any(ReadContext.class)); @@ -137,9 +138,9 @@ public class ReadableDataTreeDelegatorTest { public void testReadNonExistingNode() throws Exception { final YangInstanceIdentifier yangId = mock(YangInstanceIdentifier.class); doReturn(id).when(serializer).fromYangInstanceIdentifier(yangId); - doReturn(Optional.absent()).when(reader).read(same(id), any(ReadContext.class)); + doReturn(Optional.empty()).when(reader).read(same(id), any(ReadContext.class)); - final CheckedFuture>, ReadFailedException> future = operationalData.read(yangId); + final FluentFuture>> future = operationalData.read(yangId); verify(serializer).fromYangInstanceIdentifier(yangId); verify(reader).read(same(id), any(ReadContext.class)); @@ -151,13 +152,12 @@ public class ReadableDataTreeDelegatorTest { public void testReadFailed() throws Exception { doThrow(io.fd.honeycomb.translate.read.ReadFailedException.class).when(reader).readAll(any(ReadContext.class)); - final CheckedFuture>, ReadFailedException> future = - operationalData.read( YangInstanceIdentifier.EMPTY); + final FluentFuture>> future = operationalData.read(YangInstanceIdentifier.EMPTY); try { - future.checkedGet(); - } catch (ReadFailedException e) { - assertTrue(e.getCause() instanceof io.fd.honeycomb.translate.read.ReadFailedException); + future.get(); + } catch (ExecutionException e) { + assertTrue(e.getCause() instanceof ReadFailedException); return; } fail("ReadFailedException was expected"); @@ -181,7 +181,7 @@ public class ReadableDataTreeDelegatorTest { doReturn(vppYangId.getLastPathArgument()).when(vppStateContainer).getIdentifier(); // Read root - final CheckedFuture>, ReadFailedException> future = + final FluentFuture>> future = operationalData.read(YangInstanceIdentifier.EMPTY); verify(reader).readAll(any(ReadContext.class)); diff --git a/infra/data-impl/src/test/java/io/fd/honeycomb/data/impl/WriteTransactionTest.java b/infra/data-impl/src/test/java/io/fd/honeycomb/data/impl/WriteTransactionTest.java index 74313a1ba..8bda219cb 100644 --- a/infra/data-impl/src/test/java/io/fd/honeycomb/data/impl/WriteTransactionTest.java +++ b/infra/data-impl/src/test/java/io/fd/honeycomb/data/impl/WriteTransactionTest.java @@ -25,15 +25,16 @@ import static org.mockito.Mockito.mock; import static org.mockito.Mockito.verify; import static org.mockito.MockitoAnnotations.initMocks; -import com.google.common.util.concurrent.CheckedFuture; +import com.google.common.util.concurrent.FluentFuture; import io.fd.honeycomb.data.DataModification; import io.fd.honeycomb.translate.TranslationException; import io.fd.honeycomb.translate.ValidationFailedException; 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.TransactionCommitFailedException; +import org.opendaylight.mdsal.common.api.CommitInfo; +import org.opendaylight.mdsal.common.api.LogicalDatastoreType; +import org.opendaylight.mdsal.common.api.TransactionCommitFailedException; import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier; import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode; @@ -68,7 +69,7 @@ public class WriteTransactionTest { @Test(expected = IllegalStateException.class) public void testOnFinishedTx() { - writeTx.submit(); + writeTx.commit(); writeTx.put(LogicalDatastoreType.CONFIGURATION, path, data); verify(configSnapshot).write(path, data); } @@ -86,7 +87,7 @@ public class WriteTransactionTest { @Test public void testCancelFinished() { - writeTx.submit(); + writeTx.commit(); assertFalse(writeTx.cancel()); } @@ -98,14 +99,14 @@ public class WriteTransactionTest { @Test public void testSubmit() throws Exception { - writeTx.submit(); + writeTx.commit(); verify(configSnapshot).commit(); } @Test public void testSubmitFailed() throws Exception { doThrow(mock(ValidationFailedException.class)).when(configSnapshot).commit(); - final CheckedFuture future = writeTx.submit(); + final FluentFuture future = writeTx.commit(); try { future.get(); } catch (Exception e) { -- cgit 1.2.3-korg