Leader Election

A C# implementaion of the distributed leader election pattern using common paradigms.

Features

• Async/Await Support: Full async/await pattern support for better performance and scalability
• Comprehensive Error Handling: Robust error handling with retry logic and exponential backoff
• Structured Logging: Integration with Microsoft.Extensions.Logging for observability
• Configuration Options: Flexible configuration through options pattern
• Event-Driven: Leadership change and error events for reactive programming
• Graceful Shutdown: Proper cleanup and resource disposal
• Thread Safety: Thread-safe operations with proper synchronization

Quick Start

1. Install the Package

dotnet add package LeaderElection
dotnet add package LeaderElection.Redis

2. Configure Services

Look in LeaderElectionTester for a full example.

using LeaderElection.Redis;

var builder = WebApplication.CreateBuilder(args);

// Add Redis connection
builder.Services.AddSingleton<IConnectionMultiplexer>(sp =>
{
    return ConnectionMultiplexer.Connect("localhost:6379");
});

// Add leader election with configuration
builder.Services.AddRedisLeaderElection(settings =>
{
    settings.LockKey = "leader_election_tester";
    settings.LockExpiry = TimeSpan.FromSeconds(30);
    settings.RenewInterval = TimeSpan.FromSeconds(10);
    settings.RetryInterval = TimeSpan.FromSeconds(5);
    settings.MaxRetryAttempts = 3;
    settings.EnableGracefulShutdown = true;
});

3. Use in Your Service

public class MyService : BackgroundService
{
    private readonly RedisLeaderElection _leaderElection;
    private readonly ILogger<MyService> _logger;

    public MyService(ILeaderElection leaderElection, ILogger<MyService> logger)
    {
        _leaderElection = leaderElection;
        _logger = logger;
    }

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        // Subscribe to events
        _leaderElection.LeadershipChanged += OnLeadershipChanged;
        _leaderElection.ErrorOccurred += OnErrorOccurred;

        try
        {
            // Start leader election
            await _leaderElection.StartAsync(stoppingToken);

            // Run leader tasks
            while (!stoppingToken.IsCancellationRequested)
            {
                await _leaderElection.RunTaskIfLeaderAsync(async () =>
                {
                    _logger.LogInformation("Executing leader task");
                    await DoLeaderWorkAsync();
                }, stoppingToken);

                await Task.Delay(TimeSpan.FromSeconds(5), stoppingToken);
            }
        }
        finally
        {
            // Cleanup
            _leaderElection.LeadershipChanged -= OnLeadershipChanged;
            _leaderElection.ErrorOccurred -= OnErrorOccurred;
            await _leaderElection.StopAsync(stoppingToken);
        }
    }

    private void OnLeadershipChanged(object? sender, bool isLeader)
    {
        _logger.LogInformation("Leadership changed: {IsLeader}", isLeader);
    }

    private void OnErrorOccurred(object? sender, Exception exception)
    {
        _logger.LogError(exception, "Leader election error");
    }
}