import static org.mockito.Matchers.eq;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.reset;
import static org.mockito.Mockito.verify;
import java.util.Arrays;
ArgumentCaptor<Collection> modifications = ArgumentCaptor.forClass(Collection.class);
verify(cohort).canCommit(eq(txId), modifications.capture());
assertEquals(2, modifications.getValue().size());
-
- reset(cohort);
- doReturn(PostCanCommitStep.NOOP_SUCCESSFUL_FUTURE).when(cohort).canCommit(any(), any());
- adapter.canCommit(txId, Arrays.asList(domDataTreeCandidate), null);
- verify(cohort).canCommit(eq(txId), any());
}
}
package org.opendaylight.mdsal.binding.javav2.api;
import com.google.common.annotations.Beta;
+import java.util.Collection;
import java.util.function.BiConsumer;
import org.opendaylight.mdsal.binding.javav2.spec.base.TreeNode;
import org.opendaylight.mdsal.common.api.DataValidationFailedException;
* Performs canCommit? message in three-phase commit algorithm.
*
* @param txId Transaction identifier
- * @param modification modification of data tree
+ * @param modifications the {@link DataTreeModification} to validate
* @param callback result callback
*/
- void canCommit(Object txId, DataTreeModification<T> modification,
+ void canCommit(Object txId, Collection<DataTreeModification<T>> modifications,
BiConsumer<DataValidationFailedException, PostCanCommitStep> callback);
}
import com.google.common.annotations.Beta;
import com.google.common.base.Preconditions;
-import com.google.common.util.concurrent.CheckedFuture;
-import com.google.common.util.concurrent.Futures;
-import com.google.common.util.concurrent.ListenableFuture;
-import com.google.common.util.concurrent.MoreExecutors;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.function.BiConsumer;
+import com.google.common.util.concurrent.FluentFuture;
+import com.google.common.util.concurrent.SettableFuture;
+import java.util.Collection;
+import java.util.stream.Collectors;
import javax.annotation.Nonnull;
import org.opendaylight.mdsal.binding.javav2.api.DataTreeCommitCohort;
import org.opendaylight.mdsal.binding.javav2.api.DataTreeModification;
import org.opendaylight.mdsal.binding.javav2.dom.codec.impl.BindingToNormalizedNodeCodec;
import org.opendaylight.mdsal.binding.javav2.dom.codec.modification.LazyDataTreeModification;
import org.opendaylight.mdsal.binding.javav2.spec.base.TreeNode;
-import org.opendaylight.mdsal.common.api.DataValidationFailedException;
-import org.opendaylight.mdsal.common.api.MappingCheckedFuture;
import org.opendaylight.mdsal.common.api.PostCanCommitStep;
import org.opendaylight.mdsal.dom.api.DOMDataTreeCandidate;
import org.opendaylight.mdsal.dom.api.DOMDataTreeCommitCohort;
@Nonnull
@Override
- public CheckedFuture<PostCanCommitStep, DataValidationFailedException> canCommit(@Nonnull final Object txId,
- @Nonnull final DOMDataTreeCandidate candidate, @Nonnull final SchemaContext ctx) {
- final DataTreeModification<T> modification = LazyDataTreeModification.create(codec, candidate);
- final List<CheckedFuture<PostCanCommitStep, DataValidationFailedException>> futures = new ArrayList<>();
- final BiConsumer<DataValidationFailedException, PostCanCommitStep> biConsumer = (ex, cc) -> {
- final ListenableFuture<PostCanCommitStep> immediateFuture = Futures.immediateFuture(cc);
- futures.add(MappingCheckedFuture.create(immediateFuture,
- new DataValidationFailedExceptionMapper("canCommit", candidate.getRootPath())));
- };
- final ListenableFuture<PostCanCommitStep> resultFuture =
- Futures.transform(Futures.allAsList(futures), input -> input.get(input.size() - 1),
- MoreExecutors.directExecutor());
- cohort.canCommit(txId, modification, biConsumer);
- return MappingCheckedFuture.create(resultFuture,
- new DataValidationFailedExceptionMapper("canCommit", candidate.getRootPath()));
+ public FluentFuture<PostCanCommitStep> canCommit(Object txId, SchemaContext ctx,
+ Collection<DOMDataTreeCandidate> candidates) {
+ final Collection<DataTreeModification<T>> modifications = candidates.stream().map(
+ candidate -> LazyDataTreeModification.<T>create(codec, candidate)).collect(Collectors.toList());
+ final SettableFuture<PostCanCommitStep> resultFuture = SettableFuture.create();
+
+ cohort.canCommit(txId, modifications, (ex, pccs) -> {
+ if (ex != null) {
+ resultFuture.setException(ex);
+ } else {
+ resultFuture.set(pccs);
+ }
+ });
+
+ return resultFuture;
}
}
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
+import java.util.Arrays;
import org.junit.Test;
import org.mockito.Mockito;
import org.opendaylight.mdsal.binding.javav2.api.DataTreeCommitCohort;
assertNotNull(LazyDataTreeModification.create(codec, domDataTreeCandidate));
Mockito.doNothing().when(cohort).canCommit(any(), any(), any());
- adapter.canCommit(new Object(), domDataTreeCandidate, null);
+ adapter.canCommit(new Object(), null, Arrays.asList(domDataTreeCandidate));
verify(cohort).canCommit(any(), any(), any());
}
-}
\ No newline at end of file
+}
package org.opendaylight.mdsal.common.api;
import com.google.common.annotations.Beta;
-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 javax.annotation.Nonnull;
import org.opendaylight.yangtools.util.concurrent.FluentFutures;
}
};
- /**
- * Successful future, returning {@link #NOOP} implementation of {@link PostCanCommitStep}s.
- */
- @Deprecated
- CheckedFuture<PostCanCommitStep, DataValidationFailedException> NOOP_SUCCESS_FUTURE =
- Futures.immediateCheckedFuture(NOOP);
-
FluentFuture<PostCanCommitStep> NOOP_SUCCESSFUL_FUTURE = FluentFutures.immediateFluentFuture(NOOP);
/**
package org.opendaylight.mdsal.dom.api;
import com.google.common.annotations.Beta;
-import com.google.common.collect.Iterables;
-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 java.util.ArrayList;
import java.util.Collection;
-import java.util.List;
import javax.annotation.Nonnull;
import org.opendaylight.mdsal.common.api.DataValidationFailedException;
-import org.opendaylight.mdsal.common.api.MappingCheckedFuture;
import org.opendaylight.mdsal.common.api.PostCanCommitStep;
import org.opendaylight.yangtools.util.concurrent.ExceptionMapper;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
-import org.slf4j.LoggerFactory;
/**
* Commit cohort participating in commit of data modification, which can validate data tree
@Beta
public interface DOMDataTreeCommitCohort {
- /**
- * DO NOT implement or invoke this method. It is deprecated in favor of
- * {@link #canCommit(Object, Collection, SchemaContext)} and only exists for backwards compatibility. The
- * default implementation returns {@link PostCanCommitStep#NOOP_SUCCESS_FUTURE} and is invoked by the
- * default implementation of {@link #canCommit(Object, Collection, SchemaContext)}.
- *
- * @deprecated Implement and invoke {@link #canCommit(Object, Collection, SchemaContext)} instead.
- */
- @Deprecated
- @Nonnull
- default CheckedFuture<PostCanCommitStep, DataValidationFailedException> canCommit(@Nonnull final Object txId,
- @Nonnull final DOMDataTreeCandidate candidate, @Nonnull final SchemaContext ctx) {
- LoggerFactory.getLogger(getClass()).error(
- "The default implementation of DOMDataTreeCommitCohort#canCommit(Object, DOMDataTreeCandidate, "
- + "SchemaContext) was invoked on {}", getClass());
- return PostCanCommitStep.NOOP_SUCCESS_FUTURE;
- }
-
- /**
- * DO NOT implement or invoke this method. It is deprecated in favor of
- * {@link #canCommit(Object, SchemaContext, Collection)} which returns a {@link FluentFuture} instead of the
- * deprecated {@link CheckedFuture} which is scheduled for remkoval in a future guava release. The
- * default implementation calls {@link #canCommit(Object, SchemaContext, Collection)}.
- *
- * @deprecated Implement and invoke {@link #canCommit(Object, SchemaContext, Collection)} instead.
- */
- @Deprecated
- @Nonnull
- default CheckedFuture<PostCanCommitStep, DataValidationFailedException> canCommit(@Nonnull final Object txId,
- @Nonnull final Collection<DOMDataTreeCandidate> candidates, @Nonnull final SchemaContext ctx) {
- LoggerFactory.getLogger(getClass()).error(
- "The default implementation of DOMDataTreeCommitCohort#canCommit(Object, Collection, "
- + "SchemaContext) was invoked on {}", getClass());
-
- return MappingCheckedFuture.create(canCommit(txId, ctx, candidates), new DataValidationFailedExceptionMapper(
- "canCommit", Iterables.getLast(candidates).getRootPath()));
- }
-
/**
* Validates the supplied data tree modifications and associates the cohort-specific steps with data broker
* transaction.
* validation failure reason.
*/
@Nonnull
- default FluentFuture<PostCanCommitStep> canCommit(@Nonnull final Object txId,
- @Nonnull final SchemaContext ctx, @Nonnull final Collection<DOMDataTreeCandidate> candidates) {
- LoggerFactory.getLogger(getClass()).warn("DOMDataTreeCommitCohort implementation {} should override "
- + "canCommit(Object, SchemaContext, Collection)", getClass());
-
- // For backwards compatibility, the default implementation is to invoke the deprecated
- // canCommit(Object, DOMDataTreeCandidate, SchemaContext) method for each DOMDataTreeCandidate and return the
- // last PostCanCommitStep.
- List<ListenableFuture<PostCanCommitStep>> futures = new ArrayList<>();
- for (DOMDataTreeCandidate candidate : candidates) {
- futures.add(canCommit(txId, candidate, ctx));
- }
-
- final ListenableFuture<PostCanCommitStep> resultFuture = Futures.transform(Futures.allAsList(futures),
- input -> input.get(input.size() - 1), MoreExecutors.directExecutor());
- return FluentFuture.from(resultFuture);
- }
+ FluentFuture<PostCanCommitStep> canCommit(@Nonnull Object txId,
+ @Nonnull SchemaContext ctx, @Nonnull Collection<DOMDataTreeCandidate> candidates);
/**
* An ExceptionMapper that translates an Exception to a DataValidationFailedException.