Nancy自托管如何获取所有连接客户端的IP及会话信息

Great question! Nancy doesn’t come with a built-in global session tracker out of the box—its default session implementation is tied directly to individual request contexts, so it doesn’t actively keep tabs on all active sessions. But we can build this functionality ourselves using Nancy’s pipeline hooks and a thread-safe storage container. Here’s how to do it step by step:

1. Create a Global Session Storage Container #

First, we need a thread-safe place to store details about every active session, including the session ID, client IP, and the session object itself. ConcurrentDictionary is perfect for this since it handles multi-threaded access safely.

Add this static class (either in your Program.cs or a separate file):

using System.Collections.Concurrent;
using Nancy;

public static class SessionTracker
{
    // Key: Session ID, Value: Custom class holding client IP and session data
    public static ConcurrentDictionary<string, ClientSessionInfo> ActiveSessions { get; } 
        = new ConcurrentDictionary<string, ClientSessionInfo>();
}

public class ClientSessionInfo
{
    public string ClientIp { get; set; }
    public ISession Session { get; set; }
}

2. Hook Into Nancy’s Pipeline to Track Sessions #

Nancy’s IPipelines let us inject logic before or after each request. We’ll use the BeforeRequest hook to capture the session and client IP, then update our global storage.

Update your self-host setup in Program.cs:

using Nancy.Hosting.Self;
using System;

var hostConfig = new HostConfiguration
{
    UrlReservations = new UrlReservations { CreateAutomatically = true }
};

var host = new NancyHost(hostConfig, new Uri("http://localhost:1234"));

// Add session tracking to the request pipeline
host.Pipelines.BeforeRequest.AddItemToStartOfPipeline(ctx =>
{
    var sessionId = ctx.Request.Session.SessionId;
    var clientIp = ctx.Request.UserHostAddress;

    // Add or update the session in our tracker
    SessionTracker.ActiveSessions.AddOrUpdate(
        sessionId,
        _ => new ClientSessionInfo { ClientIp = clientIp, Session = ctx.Request.Session },
        (_, existingInfo) => 
        {
            // Refresh the IP if it changed (optional)
            existingInfo.ClientIp = clientIp;
            existingInfo.Session = ctx.Request.Session;
            return existingInfo;
        });

    // Return null to let the request continue processing normally
    return null;
});

host.Start();
Console.WriteLine("Nancy host running at http://localhost:1234");
Console.ReadLine();
host.Stop();

3. Clean Up Expired Sessions (Critical!) #

Nancy doesn’t automatically clean up expired sessions, so we need to add a background task to prune stale entries from our tracker—otherwise, we’ll end up with a memory leak.

Add this after starting the host in Program.cs:

using System.Timers;

// Clean up sessions that haven't been active in 20 minutes, every 30 minutes
var cleanupTimer = new Timer(TimeSpan.FromMinutes(30).TotalMilliseconds);
cleanupTimer.Elapsed += (_, __) =>
{
    foreach (var sessionEntry in SessionTracker.ActiveSessions)
    {
        if (DateTime.UtcNow - sessionEntry.Value.Session.LastAccessed > TimeSpan.FromMinutes(20))
        {
            SessionTracker.ActiveSessions.TryRemove(sessionEntry.Key, out _);
        }
    }
};
cleanupTimer.Start();

4. Access Active Sessions in Modules or Program #

Now you can pull up all active sessions from anywhere in your app—whether it’s a Nancy module or the Program class.

Here’s an example of an admin module that exposes session data:

using Nancy;
using System.Linq;

public class AdminModule : NancyModule
{
    public AdminModule()
    {
        Get("/admin/active-sessions", _ =>
        {
            var sessionDetails = SessionTracker.ActiveSessions.Select(kv => new
            {
                SessionId = kv.Key,
                ClientIp = kv.Value.ClientIp,
                LastActive = kv.Value.Session.LastAccessed
            }).ToList();

            return Response.AsJson(sessionDetails);
        });

        // Fetch specific session data by ID
        Get("/admin/session/{sessionId}", parameters =>
        {
            var sessionId = parameters.sessionId;
            if (SessionTracker.ActiveSessions.TryGetValue(sessionId, out var clientSession))
            {
                // Access any session value you need
                var userPreference = clientSession.Session["UserPreference"];
                return Response.AsJson(new 
                { 
                    SessionId = sessionId, 
                    ClientIp = clientSession.ClientIp,
                    UserPreference = userPreference 
                });
            }
            return HttpStatusCode.NotFound;
        });
    }
}

Key Notes to Keep in Mind #

• Thread Safety: Always use ConcurrentDictionary or another thread-safe collection—Nancy handles requests in parallel, so regular collections will cause race conditions.
• Cookie Dependence: Nancy’s default session uses cookies to track session IDs. If clients disable cookies, sessions won’t work. For cookie-less support, you’ll need to implement a custom session store (like URL rewriting), but that adds complexity.
• Privacy & Security: Be careful with how you handle client IPs and session data—make sure you’re compliant with privacy regulations (like GDPR) and don’t expose sensitive information publicly.
• Custom Session Stores: If you’re using an external session store (like Redis), you can query that store directly instead of using an in-memory dictionary. You’ll still need to track client IPs via the pipeline hook though.

内容的提问来源于stack exchange，提问作者indago