package org.opendaylight.controller.cluster.databroker;
import com.google.common.base.Preconditions;
-import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.FluentFuture;
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.VarHandle;
import java.util.Collection;
import java.util.EnumMap;
import java.util.Map;
-import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-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.DOMDataReadWriteTransaction;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;
-import org.opendaylight.controller.sal.core.spi.data.DOMStoreThreePhaseCommitCohort;
-import org.opendaylight.controller.sal.core.spi.data.DOMStoreTransactionFactory;
+import org.opendaylight.mdsal.common.api.CommitInfo;
+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.mdsal.dom.spi.store.DOMStoreThreePhaseCommitCohort;
+import org.opendaylight.mdsal.dom.spi.store.DOMStoreTransactionFactory;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
public abstract class AbstractDOMTransactionFactory<T extends DOMStoreTransactionFactory> implements AutoCloseable {
- private static final AtomicIntegerFieldUpdater<AbstractDOMTransactionFactory> UPDATER =
- AtomicIntegerFieldUpdater.newUpdater(AbstractDOMTransactionFactory.class, "closed");
+ private static final Logger LOG = LoggerFactory.getLogger(AbstractDOMTransactionFactory.class);
+ private static final VarHandle CLOSED;
+
+ static {
+ try {
+ CLOSED = MethodHandles.lookup().findVarHandle(AbstractDOMTransactionFactory.class, "closed", boolean.class);
+ } catch (NoSuchFieldException | IllegalAccessException e) {
+ throw new ExceptionInInitializerError(e);
+ }
+ }
+
private final Map<LogicalDatastoreType, T> storeTxFactories;
- private volatile int closed = 0;
+
+ private volatile boolean closed;
protected AbstractDOMTransactionFactory(final Map<LogicalDatastoreType, T> txFactories) {
this.storeTxFactories = new EnumMap<>(txFactories);
/**
* Implementations must return unique identifier for each and every call of
- * this method;
+ * this method.
*
* @return new Unique transaction identifier.
*/
protected abstract Object newTransactionIdentifier();
/**
+ * Submits a transaction asynchronously for commit.
*
- * @param transaction
- * @param cohorts
- * @return
+ * @param transaction the transaction to submit
+ * @param cohorts the associated cohorts
+ * @return a resulting Future
*/
- protected abstract CheckedFuture<Void,TransactionCommitFailedException> submit(final DOMDataWriteTransaction transaction,
- final Collection<DOMStoreThreePhaseCommitCohort> cohorts);
+ protected abstract FluentFuture<? extends CommitInfo> commit(DOMDataTreeWriteTransaction transaction,
+ Collection<DOMStoreThreePhaseCommitCohort> cohorts);
/**
+ * Creates a new read-only transaction.
*
- * @return
+ * @return the transaction instance
*/
- public final DOMDataReadOnlyTransaction newReadOnlyTransaction() {
+ public final DOMDataTreeReadTransaction newReadOnlyTransaction() {
checkNotClosed();
return new DOMBrokerReadOnlyTransaction(newTransactionIdentifier(), storeTxFactories);
/**
+ * Creates a new write-only transaction.
*
- * @return
+ * @return the transaction instance
*/
- public final DOMDataWriteTransaction newWriteOnlyTransaction() {
+ public final DOMDataTreeWriteTransaction newWriteOnlyTransaction() {
checkNotClosed();
return new DOMBrokerWriteOnlyTransaction(newTransactionIdentifier(), storeTxFactories, this);
/**
+ * Creates a new read-write transaction.
*
- * @return
+ * @return the transaction instance
*/
- public final DOMDataReadWriteTransaction newReadWriteTransaction() {
+ public final DOMDataTreeReadWriteTransaction newReadWriteTransaction() {
checkNotClosed();
- return new DOMBrokerReadWriteTransaction<>(newTransactionIdentifier(), storeTxFactories, this);
+ return new DOMBrokerReadWriteTransaction(newTransactionIdentifier(), storeTxFactories, this);
}
/**
*
* @return Map of backing transaction factories.
*/
- protected final Map<LogicalDatastoreType, T> getTxFactories() {
+ public final Map<LogicalDatastoreType, T> getTxFactories() {
return storeTxFactories;
}
*
*/
protected final void checkNotClosed() {
- Preconditions.checkState(closed == 0, "Transaction factory was closed. No further operations allowed.");
+ Preconditions.checkState(!closed, "Transaction factory was closed. No further operations allowed.");
}
@Override
public void close() {
- final boolean success = UPDATER.compareAndSet(this, 0, 1);
- Preconditions.checkState(success, "Transaction factory was already closed");
+ if (!CLOSED.compareAndSet(this, false, true)) {
+ LOG.warn("Transaction factory was already closed", new Throwable());
+ }
}
}