<groupId>org.opendaylight.yangtools</groupId>
<artifactId>yang-data-api</artifactId>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.yangtools</groupId>
+ <artifactId>yang-data-tree-api</artifactId>
+ </dependency>
<dependency>
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>yang-data-impl</artifactId>
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
+import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.mdsal.dom.spi.store.DOMStoreThreePhaseCommitCohort;
+import org.opendaylight.yangtools.yang.common.Empty;
public enum TestCommitCohort implements DOMStoreThreePhaseCommitCohort {
+ ALLWAYS_SUCCESS(true, true, true, true),
+ CAN_COMMIT_FAILED(false, false, false, true),
+ PRE_COMMIT_FAILED(true, false, false, true),
+ COMMIT_FAILED(true, true, false, true);
-
- ALLWAYS_SUCCESS(true, true, true, true), CAN_COMMIT_FAILED(false, false, false, true), PRE_COMMIT_FAILED(true,
- false, false, true), COMMIT_FAILED(true, true, false, true);
-
+ private final ListenableFuture<Boolean> canCommit;
+ private final ListenableFuture<Empty> preCommit;
+ private final ListenableFuture<CommitInfo> commit;
+ private final ListenableFuture<Empty> abort;
TestCommitCohort(final boolean canCommit, final boolean preCommit,
final boolean commit, final boolean abort) {
this.canCommit = Futures.immediateFuture(canCommit);
this.preCommit = immediate(canCommit, new IllegalStateException());
- this.commit = immediate(commit, new IllegalStateException());
+ this.commit = commit ? CommitInfo.emptyFluentFuture()
+ : Futures.immediateFailedFuture(new IllegalStateException());
this.abort = immediate(abort, new IllegalStateException());
}
- private final ListenableFuture<Boolean> canCommit;
- private final ListenableFuture<Void> preCommit;
- private final ListenableFuture<Void> commit;
- private final ListenableFuture<Void> abort;
-
@Override
public ListenableFuture<Boolean> canCommit() {
return canCommit;
}
@Override
- public ListenableFuture<Void> preCommit() {
+ public ListenableFuture<Empty> preCommit() {
return preCommit;
}
@Override
- public ListenableFuture<Void> abort() {
+ public ListenableFuture<Empty> abort() {
return abort;
}
@Override
- public ListenableFuture<Void> commit() {
+ public ListenableFuture<CommitInfo> commit() {
return commit;
}
- private static ListenableFuture<Void> immediate(final boolean isSuccess, final Exception except) {
- return isSuccess ? Futures.immediateFuture(null) : Futures.immediateFailedFuture(except);
+ private static ListenableFuture<Empty> immediate(final boolean isSuccess, final Exception except) {
+ return isSuccess ? Futures.immediateFuture(Empty.value()) : Futures.immediateFailedFuture(except);
}
-
-
-
}
import static java.util.Objects.requireNonNull;
import com.google.common.util.concurrent.ListenableFuture;
+import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.mdsal.dom.spi.store.SnapshotBackedWriteTransaction;
import org.opendaylight.yangtools.yang.data.tree.api.DataTreeModification;
}
@Override
- public ListenableFuture<Void> commit() {
- ListenableFuture<Void> ret = super.commit();
+ public ListenableFuture<CommitInfo> commit() {
+ ListenableFuture<CommitInfo> ret = super.commit();
txChain.transactionCommited(getTransaction());
return ret;
}
import com.google.common.annotations.VisibleForTesting;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
+import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.mdsal.common.api.OptimisticLockFailedException;
import org.opendaylight.mdsal.common.api.TransactionCommitFailedException;
import org.opendaylight.mdsal.dom.spi.store.AbstractDOMStoreTransaction;
import org.opendaylight.mdsal.dom.spi.store.DOMStoreThreePhaseCommitCohort;
import org.opendaylight.mdsal.dom.spi.store.SnapshotBackedWriteTransaction;
+import org.opendaylight.yangtools.yang.common.Empty;
import org.opendaylight.yangtools.yang.data.tree.api.ConflictingModificationAppliedException;
import org.opendaylight.yangtools.yang.data.tree.api.DataTreeCandidate;
import org.opendaylight.yangtools.yang.data.tree.api.DataTreeModification;
class InMemoryDOMStoreThreePhaseCommitCohort implements DOMStoreThreePhaseCommitCohort {
private static final Logger LOG = LoggerFactory.getLogger(InMemoryDOMStoreThreePhaseCommitCohort.class);
- private static final ListenableFuture<Void> SUCCESSFUL_FUTURE = Futures.immediateFuture(null);
+ private static final ListenableFuture<Empty> SUCCESSFUL_FUTURE = Futures.immediateFuture(Empty.value());
private static final ListenableFuture<Boolean> CAN_COMMIT_FUTURE = Futures.immediateFuture(Boolean.TRUE);
private final SnapshotBackedWriteTransaction<String> transaction;
@SuppressWarnings("checkstyle:IllegalCatch")
@Override
- public final ListenableFuture<Void> preCommit() {
+ public final ListenableFuture<Empty> preCommit() {
try {
candidate = store.prepare(modification);
return SUCCESSFUL_FUTURE;
}
@Override
- public final ListenableFuture<Void> abort() {
+ public final ListenableFuture<Empty> abort() {
candidate = null;
return SUCCESSFUL_FUTURE;
}
}
@Override
- public ListenableFuture<Void> commit() {
+ public ListenableFuture<CommitInfo> commit() {
checkState(candidate != null, "Proposed subtree must be computed");
- /*
- * The commit has to occur atomically with regard to listener
- * registrations.
- */
+ // The commit has to occur atomically with regard to listener registrations.
store.commit(candidate);
- return SUCCESSFUL_FUTURE;
+ return CommitInfo.emptyFluentFuture();
}
}
exports org.opendaylight.mdsal.dom.spi.query;
exports org.opendaylight.mdsal.dom.spi.store;
+ requires transitive org.opendaylight.mdsal.common.api;
requires transitive org.opendaylight.mdsal.dom.api;
+ requires transitive org.opendaylight.yangtools.yang.common;
requires transitive org.opendaylight.yangtools.yang.data.tree.api;
requires transitive org.opendaylight.yangtools.yang.model.api;
requires transitive org.opendaylight.yangtools.yang.repo.api;
package org.opendaylight.mdsal.dom.spi.store;
import com.google.common.util.concurrent.ListenableFuture;
+import org.opendaylight.mdsal.common.api.CommitInfo;
+import org.opendaylight.yangtools.yang.common.Empty;
/**
* Interface implemented by the {@link DOMStore} and exposed for each
* @return ListenableFuture representing acknowledgment for participant
* that pre-commit message was received and processed.
*/
- ListenableFuture<Void> preCommit();
+ ListenableFuture<Empty> preCommit();
/**
* Initiates a abort phase of associated transaction on data store.
* @return ListenableFuture representing acknowledgment for participant
* that abort message was received.
*/
- ListenableFuture<Void> abort();
+ ListenableFuture<Empty> abort();
/**
* Initiates a commit phase on of associated transaction on data store.
* that commit message was received and commit of transaction was
* processed.
*/
- ListenableFuture<Void> commit();
+ ListenableFuture<? extends CommitInfo> commit();
}
import com.google.common.annotations.Beta;
import com.google.common.collect.ForwardingObject;
import com.google.common.util.concurrent.ListenableFuture;
+import org.opendaylight.mdsal.common.api.CommitInfo;
+import org.opendaylight.yangtools.yang.common.Empty;
/**
- * Abstract base class for {@link DOMStoreThreePhaseCommitCohort} implementations,
- * which forward most of their functionality to a backend {@link #delegate()}.
+ * Abstract base class for {@link DOMStoreThreePhaseCommitCohort} implementations, which forward most of their
+ * functionality to a backend {@link #delegate()}.
*/
@Beta
public abstract class ForwardingDOMStoreThreePhaseCommitCohort
}
@Override
- public ListenableFuture<Void> preCommit() {
+ public ListenableFuture<Empty> preCommit() {
return delegate().preCommit();
}
@Override
- public ListenableFuture<Void> abort() {
+ public ListenableFuture<Empty> abort() {
return delegate().abort();
}
@Override
- public ListenableFuture<Void> commit() {
+ public ListenableFuture<? extends CommitInfo> commit() {
return delegate().commit();
}
}