OWIN SelfHost Web Api - Request Cancellation - How is it done? Thread aborts?

Question

Could someone point me to a resource that would help explain how web api (specifically using Owin Self Host) handles request cancellation?

Here's the sequence of events i'm observing:

• someone makes a GET from chrome
• Api controller (through some layers) fires off an async SQL query
• someone hits the X button in chrome (i don't know exactly what happens on socket for this)

What happens next in Web Api??

There was some code running in a controller, does the thread running it get aborted? If it was an async controller awaiting another Task, does that task still have an awaiter in case it returns with an exception?

For context: I do have an async controller awaiting a Task (this is the only call site) which looks to be throwing an unobserved exception in some edge cases. I haven't been able to isolate or re-produce yet :)

I did find something called HttpResponse.ClientDisconnectedToken, but don't know well that is supported in Owin Selfhost + is it even the good thing to use for all user cancels.

Answer 1

I've dealt with this by handing the System.OperationCanceledException in a custom middleware I've registered before WebApi.

public class ExceptionHanldingMiddleware : OwinMiddleware
{
    public override async Task Invoke(IOwinContext context)
    {
        try
        {
            await Next.Invoke(context);
        }
        catch (OperationCanceledException) when (context.Request.CallCancelled.IsCancellationRequested)
        {
            //swallow user-agent cancelling request.
            _log.Trace($"client disconnected on request for: {context.Request.Path}.");
        }
        catch (Exception ex)
        {
            _log.Error(ex);
            context.Response.StatusCode = (int) HttpStatusCode.InternalServerError;
            context.Response.ReasonPhrase = "Internal Server Error";
        }
    }   
}

Answer 2

As you stated that your async controller is awaiting for a Task, which sometimes got some exception, I suggest you ContinueWith extension method for a task, which can be run only then your task is faulted, like this:

task.ContinueWith(
       t =>
       logger.Error(t.Exception.Message, t.Exception);
       , TaskContinuationOptions.OnlyOnFaulted);

This is a default mechanism to handle the exceptions, and this will work in OWIN application.

Second, as for the cancellation: task can be started with a CancellationToken structure, which can be used for a cancelling the task during the execution. You can read more in the MSDN article.

HttpResponse.ClientDisconnectedToken is used for a situation when the client has been disconnected and the request should not be proceed in execution.

You can use this token, or create your own with CancellationTokenSource, like this:

var source = new CancellationTokenSource();
var token = source.Token;

var task = Task.Factory.StartNew(() =>
{

    // Were we already canceled?
    ct.ThrowIfCancellationRequested();

    var moreToDo = true;
    while (moreToDo)
    {
        // Poll on this property if you have to do 
        // other cleanup before throwing. 
        if (ct.IsCancellationRequested)
        {
            // Clean up here, then...
            ct.ThrowIfCancellationRequested();
        }

    }
}, token);