Is it possible to gracefully shutdown a Self-Hosted ServiceStack service?

Question

In a ServiceStack Self-Hosted service, is it possible to gracefully shutdown the service when if pending requests exist?

Use AppHost.Stop()? (derived from AppHostHttpListenerBase)

Answer 1

I don't think there is a built in mechanism for this, though it would be nice to see it. I use my own simplistic Graceful shutdown method.

Essentially I have a static bool, IsShuttingDown flag that is checked prior to starting each request, at the first possible opportunity in the service pipeline. (RawHttpHandlers)

If this flag is set true it means I am not wanting the service to handle any more requests, and will instead send http status 503 Unavailable to the client.

My graceful shutdown method simply sets IsShuttingDown flag and starts a timeout timer of 60 seconds to give any currently processing requests time to complete. After which the service stops calling AppHost.Stop(). (See end of question for how to do it without a timer)

My code is for ServiceStack v3, you may have to modify it slightly to get it to work with v4 if you are using that version.

In your AppHost:

public static bool IsShuttingDown = false;

public override void Configure(Funq.Container container)
{

    // Other configuration options ...

    // Handle the graceful shutdown response
    var gracefulShutdownHandler = new CustomActionHandler((httpReq, httpRes) => {
        httpRes.StatusCode = 503;
        httpRes.StatusDescription = "Unavailable";
        httpRes.Write("Service Unavailable");
        httpRes.EndRequest();
    });

    SetConfig(new EndpointHostConfig {
        // Other EndPoint configuration options ...
        RawHttpHandlers = { httpReq => IsShuttingDown ? gracefulShutdownHandler : null }
    });

}

The CustomActionHandler is just copied from here, it is responsible for handling the request. (A custom action handler is included already in v4 so it wouldn't be needed)

public class CustomActionHandler : IServiceStackHttpHandler, IHttpHandler 
{
    public Action<IHttpRequest, IHttpResponse> Action { get; set; }

    public CustomActionHandler(Action<IHttpRequest, IHttpResponse> action)
    {
        if (action == null)
            throw new Exception("Action was not supplied to ActionHandler");

        Action = action;
    }

    public void ProcessRequest(IHttpRequest httpReq, IHttpResponse httpRes, string operationName)
    {            
        Action(httpReq, httpRes);
    }

    public void ProcessRequest(HttpContext context)
    {
        ProcessRequest(context.Request.ToRequest(GetType().Name), 
            context.Response.ToResponse(),
            GetType().Name);
    }

    public bool IsReusable
    {
        get { return false; }
    }
}

---

I appreciate that using a timer doesn't guarantee that all requests will have ended in the 60 seconds, but it works for my needs, where most requests are handled in far far less time.

To avoid using a timer (immediate shutdown when all connections closed):

Because there is no access to the underlying connection pool, you would have to keep track of what connections are active.

For this method I would use the PreExecuteServiceFilter and PostExecuteServiceFilter to increment & decrement an active connections counter. I am thinking you would want to use Interlocked.Increment and Interlocked.Decrement to ensure thread safety of your count. I haven't tested this, and there is probably a better way.

In your AppHost:

public static int ConnectionCount;

// Configure Method
// As above but with additional count tracking.

    ConnectionCount = 0;

    SetConfig(new EndpointHostConfig {
        // Other EndPoint configuration options ...
        RawHttpHandlers = { httpReq => IsShuttingDown ? gracefulShutdownHandler : null },
        
        // Track active connection count
        PreExecuteServiceFilter = () => Interlocked.Increment(ref ConnectionCount),
        PostExecuteServiceFilter = (obj, req, res) => {
            Interlocked.Decrement(ref ConnectionCount);

            // Check if shutting down, and if there are no more connections, stop
            if(IsShuttingDown && ConnectionCount==0){
                res.EndRequest(); // Ensure last request gets their data before service stops.
                this.Stop();
            }
        },
    });

Hope some of this helps anyway.