import org.opendaylight.controller.cluster.access.commands.TransactionMerge;
import org.opendaylight.controller.cluster.access.commands.TransactionModification;
import org.opendaylight.controller.cluster.access.commands.TransactionPreCommitRequest;
+import org.opendaylight.controller.cluster.access.commands.TransactionPurgeRequest;
import org.opendaylight.controller.cluster.access.commands.TransactionRequest;
import org.opendaylight.controller.cluster.access.commands.TransactionSuccess;
import org.opendaylight.controller.cluster.access.commands.TransactionWrite;
private static final int REQUEST_MAX_MODIFICATIONS = 1000;
private final ModifyTransactionRequestBuilder builder;
+ private final boolean sendReadyOnSeal;
private final boolean snapshotOnly;
private boolean builderBusy;
private volatile Exception operationFailure;
+
RemoteProxyTransaction(final ProxyHistory parent, final TransactionIdentifier identifier,
- final boolean snapshotOnly) {
+ final boolean snapshotOnly, final boolean sendReadyOnSeal) {
super(parent);
this.snapshotOnly = snapshotOnly;
+ this.sendReadyOnSeal = sendReadyOnSeal;
builder = new ModifyTransactionRequestBuilder(identifier, localActor());
}
@Override
void doAbort() {
- ensureInitializedBuider();
+ ensureInitializedBuilder();
builder.setAbort();
flushBuilder();
}
- private void ensureInitializedBuider() {
+ private void ensureInitializedBuilder() {
if (!builderBusy) {
builder.setSequence(nextSequence());
builderBusy = true;
private void appendModification(final TransactionModification modification) {
if (operationFailure == null) {
- ensureInitializedBuider();
+ ensureInitializedBuilder();
builder.addModification(modification);
if (builder.size() >= REQUEST_MAX_MODIFICATIONS) {
@Override
ModifyTransactionRequest commitRequest(final boolean coordinated) {
- ensureInitializedBuider();
+ ensureInitializedBuilder();
builder.setCommit(coordinated);
final ModifyTransactionRequest ret = builder.build();
@Override
void doSeal() {
- // No-op
+ if (sendReadyOnSeal) {
+ ensureInitializedBuilder();
+ builder.setReady();
+ flushBuilder();
+ }
}
@Override
final java.util.Optional<PersistenceProtocol> maybeProto = req.getPersistenceProtocol();
if (maybeProto.isPresent()) {
- seal();
+ ensureSealed();
switch (maybeProto.get()) {
case ABORT:
case THREE_PHASE:
sendRequest(commitRequest(true), callback);
break;
+ case READY:
+ //no op
+ break;
default:
throw new IllegalArgumentException("Unhandled protocol " + maybeProto.get());
}
} else if (request instanceof TransactionAbortRequest) {
ensureFlushedBuider();
sendAbort(callback);
+ } else if (request instanceof TransactionPurgeRequest) {
+ purge();
} else {
throw new IllegalArgumentException("Unhandled request {}" + request);
}