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) {
+ RemoteProxyTransaction(final ProxyHistory parent, final TransactionIdentifier identifier,
+ final boolean snapshotOnly, final boolean sendReadyOnSeal) {
super(parent);
+ this.snapshotOnly = snapshotOnly;
+ this.sendReadyOnSeal = sendReadyOnSeal;
builder = new ModifyTransactionRequestBuilder(identifier, localActor());
}
+ @Override
+ boolean isSnapshotOnly() {
+ return snapshotOnly;
+ }
+
@Override
public TransactionIdentifier getIdentifier() {
return builder.getIdentifier();
@Override
CheckedFuture<Boolean, ReadFailedException> doExists(final YangInstanceIdentifier path) {
final SettableFuture<Boolean> future = SettableFuture.create();
- return sendReadRequest(new ExistsTransactionRequest(getIdentifier(), nextSequence(), localActor(), path),
- t -> completeExists(future, t), future);
+ return sendReadRequest(new ExistsTransactionRequest(getIdentifier(), nextSequence(), localActor(), path,
+ isSnapshotOnly()), t -> completeExists(future, t), future);
}
@Override
CheckedFuture<Optional<NormalizedNode<?, ?>>, ReadFailedException> doRead(final YangInstanceIdentifier path) {
final SettableFuture<Optional<NormalizedNode<?, ?>>> future = SettableFuture.create();
- return sendReadRequest(new ReadTransactionRequest(getIdentifier(), nextSequence(), localActor(), path),
- t -> completeRead(future, t), future);
+ return sendReadRequest(new ReadTransactionRequest(getIdentifier(), nextSequence(), localActor(), path,
+ isSnapshotOnly()), t -> completeRead(future, t), future);
}
@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:
- sendAbort(callback);
+ ensureInitializedBuilder();
+ builder.setAbort();
+ final ModifyTransactionRequest newReq = builder.build();
+ builderBusy = false;
+ sendRequest(newReq, callback);
break;
case SIMPLE:
sendRequest(commitRequest(false), callback);
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 ReadTransactionRequest) {
ensureFlushedBuider();
sendRequest(new ReadTransactionRequest(getIdentifier(), nextSequence(), localActor(),
- ((ReadTransactionRequest) request).getPath()), callback);
+ ((ReadTransactionRequest) request).getPath(), isSnapshotOnly()), callback);
} else if (request instanceof ExistsTransactionRequest) {
ensureFlushedBuider();
sendRequest(new ExistsTransactionRequest(getIdentifier(), nextSequence(), localActor(),
- ((ExistsTransactionRequest) request).getPath()), callback);
+ ((ExistsTransactionRequest) request).getPath(), isSnapshotOnly()), callback);
} else if (request instanceof TransactionPreCommitRequest) {
ensureFlushedBuider();
sendRequest(new TransactionPreCommitRequest(getIdentifier(), nextSequence(), localActor()), callback);
} else if (request instanceof TransactionAbortRequest) {
ensureFlushedBuider();
sendAbort(callback);
+ } else if (request instanceof TransactionPurgeRequest) {
+ purge();
} else {
throw new IllegalArgumentException("Unhandled request {}" + request);
}