*/
package org.opendaylight.controller.cluster.datastore;
-import com.google.common.base.Optional;
-import com.google.common.base.Preconditions;
+import static com.google.common.base.Preconditions.checkState;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.primitives.UnsignedLong;
import com.google.common.util.concurrent.FutureCallback;
import java.util.Collection;
-import javax.annotation.Nullable;
-import javax.annotation.concurrent.NotThreadSafe;
+import java.util.Optional;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.controller.cluster.access.commands.AbortLocalTransactionRequest;
import org.opendaylight.controller.cluster.access.commands.CommitLocalTransactionRequest;
import org.opendaylight.controller.cluster.access.commands.ExistsTransactionRequest;
import org.slf4j.LoggerFactory;
/**
- * Frontend read-write transaction state as observed by the shard leader.
+ * Frontend read-write transaction state as observed by the shard leader. This class is NOT thread-safe.
*
* @author Robert Varga
*/
-@NotThreadSafe
final class FrontendReadWriteTransaction extends FrontendTransaction {
private enum CommitStage {
READY,
final RequestException cause;
Failed(final RequestException cause) {
- this.cause = Preconditions.checkNotNull(cause);
+ this.cause = requireNonNull(cause);
}
@Override
final ReadWriteShardDataTreeTransaction openTransaction;
Open(final ReadWriteShardDataTreeTransaction openTransaction) {
- this.openTransaction = Preconditions.checkNotNull(openTransaction);
+ this.openTransaction = requireNonNull(openTransaction);
}
@Override
CommitStage stage;
Ready(final ShardDataTreeCohort readyCohort) {
- this.readyCohort = Preconditions.checkNotNull(readyCohort);
+ this.readyCohort = requireNonNull(readyCohort);
this.stage = CommitStage.READY;
}
final DataTreeModification sealedModification;
Sealed(final DataTreeModification sealedModification) {
- this.sealedModification = Preconditions.checkNotNull(sealedModification);
+ this.sealedModification = requireNonNull(sealedModification);
}
@Override
}
}
+ /**
+ * Retired state, needed to catch and suppress callbacks after we have removed associated state.
+ */
+ private static final class Retired extends State {
+ private final String prevStateString;
+
+ Retired(final State prevState) {
+ prevStateString = prevState.toString();
+ }
+
+ @Override
+ public String toString() {
+ return "RETIRED (in " + prevStateString + ")";
+ }
+ }
+
private static final Logger LOG = LoggerFactory.getLogger(FrontendReadWriteTransaction.class);
private static final State ABORTED = new State() {
@Override
// Sequence has already been checked
@Override
- @Nullable TransactionSuccess<?> doHandleRequest(final TransactionRequest<?> request, final RequestEnvelope envelope,
+ TransactionSuccess<?> doHandleRequest(final TransactionRequest<?> request, final RequestEnvelope envelope,
final long now) throws RequestException {
if (request instanceof ModifyTransactionRequest) {
return handleModifyTransaction((ModifyTransactionRequest) request, envelope, now);
}
}
+ @Override
+ void retire() {
+ state = new Retired(state);
+ }
+
private void handleTransactionPreCommit(final TransactionPreCommitRequest request,
final RequestEnvelope envelope, final long now) throws RequestException {
throwIfFailed();
ready.readyCohort.preCommit(new FutureCallback<DataTreeCandidate>() {
@Override
public void onSuccess(final DataTreeCandidate result) {
- LOG.debug("{}: Transaction {} completed preCommit", persistenceId(), getIdentifier());
- recordAndSendSuccess(envelope, now, new TransactionPreCommitSuccess(getIdentifier(),
- request.getSequence()));
- ready.stage = CommitStage.PRE_COMMIT_COMPLETE;
+ successfulPreCommit(envelope, now);
}
@Override
case READY:
throw new IllegalStateException("Attempted to preCommit in stage " + ready.stage);
default:
- throw new IllegalStateException("Unhandled commit stage " + ready.stage);
+ throwUnhandledCommitStage(ready);
+ }
+ }
+
+ void successfulPreCommit(final RequestEnvelope envelope, final long startTime) {
+ if (state instanceof Retired) {
+ LOG.debug("{}: Suppressing successful preCommit of retired transaction {}", persistenceId(),
+ getIdentifier());
+ return;
}
+
+ final Ready ready = checkReady();
+ LOG.debug("{}: Transaction {} completed preCommit", persistenceId(), getIdentifier());
+ recordAndSendSuccess(envelope, startTime, new TransactionPreCommitSuccess(getIdentifier(),
+ envelope.getMessage().getSequence()));
+ ready.stage = CommitStage.PRE_COMMIT_COMPLETE;
}
- private void failTransaction(final RequestEnvelope envelope, final long now, final RuntimeRequestException cause) {
+ void failTransaction(final RequestEnvelope envelope, final long now, final RuntimeRequestException cause) {
+ if (state instanceof Retired) {
+ LOG.debug("{}: Suppressing failure of retired transaction {}", persistenceId(), getIdentifier(), cause);
+ return;
+ }
+
recordAndSendFailure(envelope, now, cause);
state = new Failed(cause);
LOG.debug("{}: Transaction {} failed", persistenceId(), getIdentifier(), cause);
case READY:
throw new IllegalStateException("Attempted to doCommit in stage " + ready.stage);
default:
- throw new IllegalStateException("Unhandled commit stage " + ready.stage);
+ throwUnhandledCommitStage(ready);
}
}
checkReady().readyCohort.canCommit(new FutureCallback<Void>() {
@Override
public void onSuccess(final Void result) {
- recordAndSendSuccess(envelope, now, new TransactionCanCommitSuccess(getIdentifier(),
- envelope.getMessage().getSequence()));
- ready.stage = CommitStage.CAN_COMMIT_COMPLETE;
- LOG.debug("{}: Transaction {} completed canCommit", persistenceId(), getIdentifier());
+ successfulCanCommit(envelope, now);
}
@Override
case PRE_COMMIT_PENDING:
throw new IllegalStateException("Attempted to canCommit in stage " + ready.stage);
default:
- throw new IllegalStateException("Unhandled commit stage " + ready.stage);
+ throwUnhandledCommitStage(ready);
+ }
+ }
+
+ void successfulCanCommit(final RequestEnvelope envelope, final long startTime) {
+ if (state instanceof Retired) {
+ LOG.debug("{}: Suppressing successful canCommit of retired transaction {}", persistenceId(),
+ getIdentifier());
+ return;
}
+
+ final Ready ready = checkReady();
+ recordAndSendSuccess(envelope, startTime, new TransactionCanCommitSuccess(getIdentifier(),
+ envelope.getMessage().getSequence()));
+ ready.stage = CommitStage.CAN_COMMIT_COMPLETE;
+ LOG.debug("{}: Transaction {} completed canCommit", persistenceId(), getIdentifier());
}
private void directCommit(final RequestEnvelope envelope, final long now) throws RequestException {
});
break;
default:
- throw new IllegalStateException("Unhandled commit stage " + ready.stage);
+ throwUnhandledCommitStage(ready);
}
}
void successfulDirectCanCommit(final RequestEnvelope envelope, final long startTime) {
+ if (state instanceof Retired) {
+ LOG.debug("{}: Suppressing direct canCommit of retired transaction {}", persistenceId(), getIdentifier());
+ return;
+ }
+
final Ready ready = checkReady();
ready.stage = CommitStage.PRE_COMMIT_PENDING;
LOG.debug("{}: Transaction {} initiating direct preCommit", persistenceId(), getIdentifier());
}
void successfulDirectPreCommit(final RequestEnvelope envelope, final long startTime) {
+ if (state instanceof Retired) {
+ LOG.debug("{}: Suppressing direct commit of retired transaction {}", persistenceId(), getIdentifier());
+ return;
+ }
+
final Ready ready = checkReady();
ready.stage = CommitStage.COMMIT_PENDING;
LOG.debug("{}: Transaction {} initiating direct commit", persistenceId(), getIdentifier());
}
void successfulCommit(final RequestEnvelope envelope, final long startTime) {
+ if (state instanceof Retired) {
+ LOG.debug("{}: Suppressing commit response on retired transaction {}", persistenceId(), getIdentifier());
+ return;
+ }
+
recordAndSendSuccess(envelope, startTime, new TransactionCommitSuccess(getIdentifier(),
envelope.getMessage().getSequence()));
state = COMMITTED;
throw new UnsupportedRequestException(request);
}
- final java.util.Optional<Exception> optFailure = request.getDelayedFailure();
+ final Optional<Exception> optFailure = request.getDelayedFailure();
if (optFailure.isPresent()) {
state = new Ready(history().createFailedCohort(getIdentifier(), sealedModification, optFailure.get()));
} else {
- state = new Ready(history().createReadyCohort(getIdentifier(), sealedModification));
+ state = new Ready(history().createReadyCohort(getIdentifier(), sealedModification, Optional.empty()));
}
if (request.isCoordinated()) {
}
}
- private ExistsTransactionSuccess handleExistsTransaction(final ExistsTransactionRequest request)
- throws RequestException {
- final Optional<NormalizedNode<?, ?>> data = checkOpen().getSnapshot().readNode(request.getPath());
+ private ExistsTransactionSuccess handleExistsTransaction(final ExistsTransactionRequest request) {
+ final Optional<NormalizedNode> data = checkOpen().getSnapshot().readNode(request.getPath());
return recordSuccess(request.getSequence(), new ExistsTransactionSuccess(getIdentifier(), request.getSequence(),
data.isPresent()));
}
- private ReadTransactionSuccess handleReadTransaction(final ReadTransactionRequest request)
- throws RequestException {
- final Optional<NormalizedNode<?, ?>> data = checkOpen().getSnapshot().readNode(request.getPath());
+ private ReadTransactionSuccess handleReadTransaction(final ReadTransactionRequest request) {
+ final Optional<NormalizedNode> data = checkOpen().getSnapshot().readNode(request.getPath());
return recordSuccess(request.getSequence(), new ReadTransactionSuccess(getIdentifier(), request.getSequence(),
data));
}
final RequestEnvelope envelope, final long now) throws RequestException {
// We need to examine the persistence protocol first to see if this is an idempotent request. If there is no
// protocol, there is nothing for us to do.
- final
java.util.Optional<PersistenceProtocol> maybeProto = request.getPersistenceProtocol();
+ final Optional<PersistenceProtocol> maybeProto = request.getPersistenceProtocol();
if (!maybeProto.isPresent()) {
applyModifications(request.getModifications());
return replyModifySuccess(request.getSequence());
}
applyModifications(modifications);
- state = new Ready(checkOpen().ready());
+ state = new Ready(checkOpen().ready(Optional.empty()));
LOG.debug("{}: transitioned {} to ready", persistenceId(), getIdentifier());
}
}
private ReadWriteShardDataTreeTransaction checkOpen() {
- Preconditions.checkState(state instanceof Open, "%s expect to be open, is in state %s", getIdentifier(),
- state);
+ checkState(state instanceof Open, "%s expect to be open, is in state %s", getIdentifier(), state);
return ((Open) state).openTransaction;
}
private Ready checkReady() {
- Preconditions.checkState(state instanceof Ready, "%s expect to be ready, is in state %s", getIdentifier(),
- state);
+ checkState(state instanceof Ready, "%s expect to be ready, is in state %s", getIdentifier(), state);
return (Ready) state;
}
private DataTreeModification checkSealed() {
- Preconditions.checkState(state instanceof Sealed, "%s expect to be sealed, is in state %s", getIdentifier(),
- state);
+ checkState(state instanceof Sealed, "%s expect to be sealed, is in state %s", getIdentifier(), state);
return ((Sealed) state).sealedModification;
}
+
+ private static void throwUnhandledCommitStage(final Ready ready) {
+ throw new IllegalStateException("Unhandled commit stage " + ready.stage);
+ }
}
Code Review / controller.git / blobdiff