import com.google.common.util.concurrent.CheckedFuture;
import com.google.common.util.concurrent.Futures;
import java.util.function.Consumer;
+import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import javax.annotation.concurrent.NotThreadSafe;
import org.opendaylight.controller.cluster.access.commands.AbortLocalTransactionRequest;
private final TransactionIdentifier identifier;
- LocalProxyTransaction(final ProxyHistory parent, final TransactionIdentifier identifier) {
- super(parent);
+ LocalProxyTransaction(final ProxyHistory parent, final TransactionIdentifier identifier, final boolean isDone) {
+ super(parent, isDone);
this.identifier = Preconditions.checkNotNull(identifier);
}
return identifier;
}
+ @Nonnull
abstract DataTreeSnapshot readOnlyView();
abstract void applyForwardedModifyTransactionRequest(ModifyTransactionRequest request,
@Override
final CheckedFuture<Optional<NormalizedNode<?, ?>>, ReadFailedException> doRead(final YangInstanceIdentifier path) {
- return Futures.immediateCheckedFuture(readOnlyView().readNode(path));
+ return Futures.immediateCheckedFuture(Optional.fromJavaUtil(readOnlyView().readNode(path)));
}
@Override
}
private boolean handleReadRequest(final TransactionRequest<?> request,
- final @Nullable Consumer<Response<?, ?>> callback) {
+ @Nullable final Consumer<Response<?, ?>> callback) {
// Note we delay completion of read requests to limit the scope at which the client can run, as they have
// listeners, which we do not want to execute while we are reconnecting.
if (request instanceof ReadTransactionRequest) {
final YangInstanceIdentifier path = ((ReadTransactionRequest) request).getPath();
- final Optional<NormalizedNode<?, ?>> result = readOnlyView().readNode(path);
+ final Optional<NormalizedNode<?, ?>> result = Optional.fromJavaUtil(readOnlyView().readNode(path));
if (callback != null) {
// XXX: FB does not see that callback is final, on stack and has be check for non-null.
final Consumer<Response<?, ?>> fbIsStupid = Preconditions.checkNotNull(callback);
@Override
void handleReplayedRemoteRequest(final TransactionRequest<?> request,
- final @Nullable Consumer<Response<?, ?>> callback, final long enqueuedTicks) {
+ @Nullable final Consumer<Response<?, ?>> callback, final long enqueuedTicks) {
if (request instanceof ModifyTransactionRequest) {
replayModifyTransactionRequest((ModifyTransactionRequest) request, callback, enqueuedTicks);
} else if (handleReadRequest(request, callback)) {
} else if (handleReadRequest(request, callback)) {
// No-op
} else if (request instanceof TransactionPurgeRequest) {
- sendPurge(callback);
+ enqueuePurge(callback);
} else {
throw new IllegalArgumentException("Unhandled request " + request);
}
}
});
- successor.ensureSealed();
-
+ successor.sealOnly();
final ModifyTransactionRequest successorReq = successor.commitRequest(req.isCoordinated());
successor.sendRequest(successorReq, callback);
} else if (request instanceof AbortLocalTransactionRequest) {
successor.abort();
} else if (request instanceof TransactionPurgeRequest) {
LOG.debug("Forwarding purge {} to successor {}", request, successor);
- successor.sendPurge(callback);
+ successor.enqueuePurge(callback);
+ } else if (request instanceof ModifyTransactionRequest) {
+ successor.handleForwardedRequest(request, callback);
} else {
- throw new IllegalArgumentException("Unhandled request" + request);
+ throwUnhandledRequest(request);
}
}
if (request instanceof AbortLocalTransactionRequest) {
successor.sendAbort(request, callback);
} else if (request instanceof TransactionPurgeRequest) {
- successor.sendPurge(callback);
+ successor.enqueuePurge(callback);
} else {
- throw new IllegalArgumentException("Unhandled request" + request);
+ throwUnhandledRequest(request);
}
LOG.debug("Forwarded request {} to successor {}", request, successor);
}
+ private static void throwUnhandledRequest(final TransactionRequest<?> request) {
+ throw new IllegalArgumentException("Unhandled request" + request);
+ }
+
void sendAbort(final TransactionRequest<?> request, final Consumer<Response<?, ?>> callback) {
sendRequest(request, callback);
}