Motivation:

Currently, a CancellationScheduler doesn't complete the callback ClientRequestContext#whenResponseCancelled if CancellationScheduler#init is not called.

This isn't a problem for server side since CancellationScheduler#init is called immediately. However, for client side CancellationScheduler#init is called when a HttpResponse is subscribed to. For this reason, even if we call ClientRequestContext#cancel the callback ClientRequestContext#whenResponseCancelled is never completed.

We have recently decided that the semantics of "ClientRequestContext#cancel" means:

• Client side: A failure when the response has not been fully received
• Server side: A failure then the response has not been fully sent

This means we should be able to finish a CancellationScheduler although it hasn't been initialized yet.
In order to achieve this, I propose that the following changes are made.

• An event loop is assigned to CancellationScheduler at an earlier timing so that ctx.cancel is run from an event loop.
  • This is done so CancellationScheduler#finish can be called before CancellationScheduler#start without worrying about race conditions
• The previous CancellationScheduler#init method has been divided into two methods: CancellationScheduler#init and CancellationScheduler#start
  • CancellationScheduler#init initializes the CancellationScheduler with an EventExecutor
  • CancellationScheduler#start actually starts the cancellation timer if the timeout > 0
• DefaultClientRequestContext#init is called as soon as an EventExecutor is assigned
• With the new semantics of ctx#cancel, I believe the request should be cancellable from more locations in the future. I propose that:
  • If a timeout has already been reached when CancellationScheduler#start is called, then the task is executed immediately.
  • If a task already exists, the task is updated another invocation of CancellationScheduler#start

I imagine we can later introduce a responseTimeStartTiming parameter, which dictates where to call CancellationScheduler#start from.

enum ResponseTimeTiming {
  CTX_INIT, // calls CancellationScheduler#start right after `ctx.init` is done
  DELEGATE_EXECUTE, // calls CancellationScheduler#start right after `HttpClientDelegate#execute` is done.
  RESPONSE_HEADERS // calls CancellationScheduler#start when the first response header is received (current behavior)
}

Each location may also update the cancellation task since how to cancel from each step will be different.

e.g. Cancellation from HttpClientDelegate#execute

public HttpResponse execute(ClientRequestContext ctx, ...) {
...
    final DecodedHttpResponse res = new DecodedHttpResponse(eventLoop);
    final CancellationScheduler cancellationScheduler = ...
    cancellationScheduler.start(new CancellationTask() {
        @Override
        public void run(Throwable cause) {
            final UnprocessedRequestException wrappedCause = UnprocessedRequestException.of(cause);
            handleEarlyRequestException(ctx, req, wrappedCause);
            res.close(wrappedCause);
        }
    });
...

This will be handled in a follow-up PR if it makes sense

Modifications:

• Renamed CancellationScheduler#init to CancellationScheduler#initAndStart
  • CancellationScheduler#init initializes the CancellationScheduler with an EventExecutor
  • CancellationScheduler#start updates the task and schedules a timeout if not done already
• CancellationScheduler#init is now called immediately when an event loop is updated in DefaultClientRequestContext
• Modified CancellationScheduler such that finishNow executes from an event loop
  • finishNow completes the state if even if it hasn't been started yet
• (Cleanup) Removed the timeoutNanos parameter from CancellationScheduler#start since the parameter wasn't adding any value
• (Cleanup) Changed the visibility of isInitialized since it wasn't being used anywhere
• (Cleanup) Renamed CancellationScheduler#of to CancellationScheduler#ofClient, CancellationScheduler#ofServer for clarity

Result:

• ctx.whenCancelled, ctx.whenCancelling is now completed even if the CancellationScheduler has not been initialized