import java.util.AbstractMap.SimpleEntry;
import java.util.Map.Entry;
import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;
+import org.opendaylight.mdsal.dom.spi.store.SnapshotBackedReadTransaction.TransactionClosePrototype;
import org.opendaylight.mdsal.dom.spi.store.SnapshotBackedWriteTransaction.TransactionReadyPrototype;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeModification;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeSnapshot;
*/
@Beta
public abstract class AbstractSnapshotBackedTransactionChain<T>
- extends TransactionReadyPrototype<T> implements DOMStoreTransactionChain {
+ extends TransactionReadyPrototype<T> implements DOMStoreTransactionChain, TransactionClosePrototype<T> {
private abstract static class State {
/**
* Allocate a new snapshot.
protected DOMStoreReadTransaction newReadOnlyTransaction(T transactionId) {
final Entry<State, DataTreeSnapshot> entry = getSnapshot();
return SnapshotBackedTransactions.newReadTransaction(transactionId,
- getDebugTransactions(), entry.getValue());
+ getDebugTransactions(), entry.getValue(), this);
+ }
+
+ @Override
+ public void transactionClosed(final SnapshotBackedReadTransaction<T> tx) {
+ // Defaults to no-op
}
@Override
if (allocated.getTransaction().equals(tx)) {
final boolean success = STATE_UPDATER.compareAndSet(this, localState, idleState);
if (!success) {
- LOG.warn("Transaction {} aborted, but chain {} s"
- + "tate already transitioned from {} to {}, very strange",
- tx, this, localState, state);
+ LOG.warn("Transaction {} aborted, but chain {} state already transitioned from {} to {}, "
+ + "very strange", tx, this, localState, state);
}
}
}
import com.google.common.util.concurrent.FluentFuture;
import com.google.common.util.concurrent.MoreExecutors;
import java.util.Optional;
+import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;
import org.opendaylight.mdsal.common.api.ReadFailedException;
import org.opendaylight.yangtools.util.concurrent.FluentFutures;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
@Beta
public final class SnapshotBackedReadTransaction<T> extends
AbstractDOMStoreTransaction<T> implements DOMStoreReadTransaction, SnapshotBackedTransaction {
-
private static final Logger LOG = LoggerFactory.getLogger(SnapshotBackedReadTransaction.class);
+
+ @SuppressWarnings("rawtypes")
+ private static final AtomicReferenceFieldUpdater<SnapshotBackedReadTransaction, DataTreeSnapshot> SNAPSHOT_UPDATER =
+ AtomicReferenceFieldUpdater.newUpdater(SnapshotBackedReadTransaction.class, DataTreeSnapshot.class,
+ "stableSnapshot");
+
+ // Guarded by stableSnapshot CAS, hence it does not need to be volatile
+ private TransactionClosePrototype<T> closeImpl;
private volatile DataTreeSnapshot stableSnapshot;
/**
* @param debug Enable transaction debugging
* @param snapshot Snapshot which will be modified.
*/
- SnapshotBackedReadTransaction(final T identifier, final boolean debug, final DataTreeSnapshot snapshot) {
+ SnapshotBackedReadTransaction(final T identifier, final boolean debug, final DataTreeSnapshot snapshot,
+ final TransactionClosePrototype<T> closeImpl) {
super(identifier, debug);
this.stableSnapshot = requireNonNull(snapshot);
+ this.closeImpl = closeImpl;
LOG.debug("ReadOnly Tx: {} allocated with snapshot {}", identifier, snapshot);
}
@Override
public void close() {
+ final DataTreeSnapshot prev = SNAPSHOT_UPDATER.getAndSet(this, null);
+ if (prev == null) {
+ LOG.debug("Store transaction: {} : previously closed", getIdentifier());
+ return;
+ }
+
LOG.debug("Store transaction: {} : Closed", getIdentifier());
- stableSnapshot = null;
+ if (closeImpl != null) {
+ closeImpl.transactionClosed(this);
+ closeImpl = null;
+ }
}
@SuppressWarnings("checkstyle:IllegalCatch")
public java.util.Optional<DataTreeSnapshot> getSnapshot() {
return java.util.Optional.ofNullable(stableSnapshot);
}
+
+ /**
+ * Prototype implementation of {@link SnapshotBackedReadTransaction#close()}.
+ *
+ * <p>
+ * This class is intended to be implemented by Transaction factories responsible for allocation
+ * of {@link org.opendaylight.mdsal.dom.spi.store.SnapshotBackedReadTransaction} and
+ * providing underlying logic for applying implementation.
+ *
+ * @param <T> identifier type
+ */
+ public interface TransactionClosePrototype<T> {
+ /**
+ * Called when a transaction is closed. This is not invoked at most once for every transaction.
+ *
+ * @param tx Transaction which got closed.
+ */
+ void transactionClosed(SnapshotBackedReadTransaction<T> tx);
+ }
}
*/
package org.opendaylight.mdsal.dom.spi.store;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.annotations.Beta;
+import org.eclipse.jdt.annotation.NonNull;
+import org.opendaylight.mdsal.dom.spi.store.SnapshotBackedReadTransaction.TransactionClosePrototype;
import org.opendaylight.mdsal.dom.spi.store.SnapshotBackedWriteTransaction.TransactionReadyPrototype;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeSnapshot;
/**
* Creates a new read-only transaction.
+ *
* @param identifier Transaction Identifier
* @param debug Enable transaction debugging
* @param snapshot Snapshot which will be modified.
+ * @return A new read-only transaction
*/
- public static <T> SnapshotBackedReadTransaction<T> newReadTransaction(final T identifier,
+ public static <T> @NonNull SnapshotBackedReadTransaction<T> newReadTransaction(final T identifier,
final boolean debug, final DataTreeSnapshot snapshot) {
- return new SnapshotBackedReadTransaction<>(identifier, debug, snapshot);
+ return new SnapshotBackedReadTransaction<>(identifier, debug, snapshot, null);
+ }
+
+ /**
+ * Creates a new read-only transaction.
+ *
+ * @param identifier Transaction Identifier
+ * @param debug Enable transaction debugging
+ * @param snapshot Snapshot which will be modified.
+ * @param closeImpl Implementation of close method
+ * @return A new read-only transaction
+ */
+ public static <T> @NonNull SnapshotBackedReadTransaction<T> newReadTransaction(final T identifier,
+ final boolean debug, final DataTreeSnapshot snapshot, final TransactionClosePrototype<T> closeImpl) {
+ return new SnapshotBackedReadTransaction<>(identifier, debug, snapshot, requireNonNull(closeImpl));
}
/**
* @param debug Enable transaction debugging
* @param snapshot Snapshot which will be modified.
* @param readyImpl Implementation of ready method.
+ * @return A new read-write transaction
*/
- public static <T> SnapshotBackedReadWriteTransaction<T> newReadWriteTransaction(final T identifier,
+ public static <T> @NonNull SnapshotBackedReadWriteTransaction<T> newReadWriteTransaction(final T identifier,
final boolean debug, final DataTreeSnapshot snapshot, final TransactionReadyPrototype<T> readyImpl) {
return new SnapshotBackedReadWriteTransaction<>(identifier, debug, snapshot, readyImpl);
}
* @param debug Enable transaction debugging
* @param snapshot Snapshot which will be modified.
* @param readyImpl Implementation of ready method.
+ * @return A new write transaction
*/
- public static <T> SnapshotBackedWriteTransaction<T> newWriteTransaction(final T identifier,
+ public static <T> @NonNull SnapshotBackedWriteTransaction<T> newWriteTransaction(final T identifier,
final boolean debug, final DataTreeSnapshot snapshot, final TransactionReadyPrototype<T> readyImpl) {
return new SnapshotBackedWriteTransaction<>(identifier, debug, snapshot, readyImpl);
}
public class SnapshotBackedReadTransactionTest {
private static final DataTreeSnapshot DATA_TREE_SNAPSHOT = mock(DataTreeSnapshot.class);
- private static SnapshotBackedReadTransaction<Object> snapshotBackedReadTransaction =
- new SnapshotBackedReadTransaction<>(new Object(), false, DATA_TREE_SNAPSHOT);
+
+ private SnapshotBackedReadTransaction<Object> snapshotBackedReadTransaction =
+ new SnapshotBackedReadTransaction<>(new Object(), false, DATA_TREE_SNAPSHOT, null);
@Test
public void basicTest() throws Exception {
@Test(expected = ReadFailedException.class)
public void readNodeTestWithException() throws Throwable {
doThrow(new NullPointerException("no Node")).when(DATA_TREE_SNAPSHOT).readNode(any());
- snapshotBackedReadTransaction = new SnapshotBackedReadTransaction<>(new Object(), false, DATA_TREE_SNAPSHOT);
+ snapshotBackedReadTransaction = new SnapshotBackedReadTransaction<>(new Object(), false, DATA_TREE_SNAPSHOT,
+ null);
try {
snapshotBackedReadTransaction.read(YangInstanceIdentifier.EMPTY).get();
fail("Expected ReadFailedException");