Name: Zetian.Storage.Redis
Author: Taiizor

Zetian.Storage.Redis — nugetz

# Install SMTP Server and Storage Provider
dotnet add package Zetian
dotnet add package Zetian.Storage.Redis

using Zetian.Server;
using Zetian.Storage.Redis.Extensions;

// Configure with connection string
var server = new SmtpServerBuilder()
    .Port(25)
    .WithRedisStorage("localhost:6379")
    .Build();

await server.StartAsync();

var server = new SmtpServerBuilder()
    .Port(25)
    .WithRedisStorage(
        "localhost:6379,password=mypassword",
        config =>
        {
            config.DatabaseNumber = 1;
            config.KeyPrefix = "smtp:msg:";
            config.MessageTTLSeconds = 3600; // 1 hour cache
            config.EnableChunking = true;
            config.ChunkSizeKB = 64;
            config.UseRedisStreams = true;
            config.EnablePubSub = true;
            config.MaintainIndex = true;
            config.CompressMessageBody = true;
        })
    .Build();

Option	Type	Default	Description
`ConnectionString`	string	-	Redis connection string (required)
`DatabaseNumber`	int	0	Redis database number (0-15)
`KeyPrefix`	string	"smtp:"	Prefix for all Redis keys
`MessageTTLSeconds`	int	3600	Message expiration time in seconds
`EnableChunking`	bool	true	Split large messages into chunks
`ChunkSizeKB`	int	64	Size of each chunk in KB
`UseRedisStreams`	bool	false	Use Redis Streams for storage
`StreamKey`	string	"smtp:stream"	Key for Redis Stream
`EnablePubSub`	bool	false	Enable Pub/Sub notifications
`PubSubChannel`	string	"smtp:notifications"	Channel for notifications
`MaintainIndex`	bool	true	Maintain sorted set index
`IndexKey`	string	"smtp:index"	Key for sorted set index
`MaxMessageSizeMB`	double	100	Maximum message size in MB
`CompressMessageBody`	bool	false	Compress message bodies
`EnableRetry`	bool	true	Enable retry logic
`MaxRetryAttempts`	int	3	Maximum retry attempts
`RetryDelayMs`	int	1000	Delay between retries
`ConnectionTimeoutSeconds`	int	30	Connection timeout
`LogErrors`	bool	true	Whether to log errors

// Standalone server
.WithRedisStorage("localhost:6379")

// With password
.WithRedisStorage("localhost:6379,password=mypassword")

// Multiple endpoints (replica)
.WithRedisStorage("server1:6379,server2:6379")

// With SSL/TLS
.WithRedisStorage("localhost:6379,ssl=true,sslHost=redis.example.com")

// Redis Sentinel
.WithRedisStorage("sentinel1:26379,sentinel2:26379,serviceName=mymaster")

// Redis Cluster
.WithRedisStorage("cluster1:7000,cluster2:7001,cluster3:7002")

// Messages stored as regular Redis keys
config.UseRedisStreams = false;

// Storage pattern:
// smtp:msg:{messageId}        - Message data
// smtp:meta:{messageId}       - Message metadata
// smtp:chunk:{messageId}:{n}  - Message chunks (if chunked)

// Use Redis Streams for event-driven architectures
config.UseRedisStreams = true;
config.StreamKey = "smtp:stream";

// Consume messages from stream
var entries = await db.StreamReadAsync("smtp:stream", "0-0");

// Automatically chunk large messages
config.EnableChunking = true;
config.ChunkSizeKB = 64; // 64KB chunks
config.MaxMessageSizeMB = 50; // Support up to 50MB messages

-- Key-Value storage
SET smtp:msg:123 "<message_body>"
HSET smtp:meta:123 "from" "sender@example.com" "size" "2048"

-- Chunked storage
SET smtp:chunk:123:0 "<chunk_0>"
SET smtp:chunk:123:1 "<chunk_1>"
HSET smtp:meta:123 "chunks" "2"

-- Sorted Set Index
ZADD smtp:index <timestamp> "123"

-- Redis Stream
XADD smtp:stream * messageId "123" data "<message_data>"

// Enable real-time notifications
config.EnablePubSub = true;
config.PubSubChannel = "smtp:notifications";

// Subscribe to notifications
var subscriber = redis.GetSubscriber();
subscriber.Subscribe("smtp:notifications", (channel, message) =>
{
    var notification = JsonSerializer.Deserialize<MessageNotification>(message);
    Console.WriteLine($"New message: {notification.MessageId}");
});

// Notification format
{
  "Event": "MessageStored",
  "MessageId": "msg-123",
  "Timestamp": "2024-01-01T12:00:00Z",
  "Size": 2048
}

config.ConnectionString = "localhost:6379," +
    "connectTimeout=5000," +
    "syncTimeout=5000," +
    "asyncTimeout=5000," +
    "keepAlive=60," +
    "abortConnect=false";

// Batch multiple operations
var batch = db.CreateBatch();
var tasks = new List<Task>();

foreach (var message in messages)
{
    tasks.Add(batch.StringSetAsync($"smtp:msg:{message.Id}", message.Body));
    tasks.Add(batch.HashSetAsync($"smtp:meta:{message.Id}", metadata));
}

batch.Execute();
await Task.WhenAll(tasks);

// Use compression for large messages
config.CompressMessageBody = true;

// Set appropriate TTL
config.MessageTTLSeconds = 3600; // 1 hour

// Use eviction policies
// In redis.conf: maxmemory-policy allkeys-lru

// Configure for Redis Cluster
config.ConnectionString = 
    "node1:7000,node2:7001,node3:7002," +
    "connectTimeout=5000," +
    "configCheckSeconds=60";

// Use hash tags for related keys
config.KeyPrefix = "smtp:{msg}:"; // All message keys on same slot

// Get Redis server statistics
var info = await db.ExecuteAsync("INFO", "memory");
Console.WriteLine($"Memory usage: {info}");

// Track message count
await db.StringIncrementAsync("smtp:stats:message_count");

// Track total size
await db.StringIncrementAsync("smtp:stats:total_size", message.Size);

// Get statistics
var count = await db.StringGetAsync("smtp:stats:message_count");
var totalSize = await db.StringGetAsync("smtp:stats:total_size");

# Monitor Redis commands in real-time
redis-cli monitor

# Check memory usage
redis-cli info memory

# Check connected clients
redis-cli client list

config.ConnectionString = 
    "myredis.redis.cache.windows.net:6380," +
    "password=<access_key>," +
    "ssl=True," +
    "abortConnect=False";

config.ConnectionString = 
    "mycluster.abc123.ng.0001.use1.cache.amazonaws.com:6379";

// With encryption in-transit
config.ConnectionString = 
    "mycluster.abc123.ng.0001.use1.cache.amazonaws.com:6379," +
    "ssl=true";

config.ConnectionString = 
    "10.0.0.3:6379"; // Internal IP

// With AUTH
config.ConnectionString = 
    "10.0.0.3:6379,password=AUTH_STRING";

// Use strong passwords
config.ConnectionString = "localhost:6379,password=StrongPassword123!";

// Use ACL (Redis 6.0+)
config.ConnectionString = "localhost:6379,user=smtp_app,password=AppPassword";

// Enable SSL/TLS
config.ConnectionString = 
    "localhost:6379," +
    "ssl=true," +
    "sslHost=redis.example.com," +
    "sslProtocols=Tls12";

# Bind to specific interface (redis.conf)
bind 127.0.0.1 ::1

# Enable protected mode
protected-mode yes

# Firewall rules
iptables -A INPUT -p tcp --dport 6379 -s 10.0.0.0/8 -j ACCEPT
iptables -A INPUT -p tcp --dport 6379 -j DROP

// Increase timeout values
config.ConnectionString = "localhost:6379," +
    "connectTimeout=10000," +
    "syncTimeout=10000";

# Check memory usage
redis-cli --bigkeys
redis-cli --memkeys

# Set memory limit
CONFIG SET maxmemory 2gb
CONFIG SET maxmemory-policy allkeys-lru

Soferity/Zetian.Storage.Redisv1.0.4

Get Started

Readme

Zetian.Storage.Redis - Redis Storage

⚡ Features

📦 Installation

🚀 Quick Start

Basic Configuration

Advanced Configuration

🛠️ Configuration Options

🎯 Usage Examples

Connection String Options

Storage Strategies

Key-Value Storage (Default)

Redis Streams

Chunking for Large Messages

📊 Redis Data Structures

Message Storage

Pub/Sub Notifications

🚀 Performance Optimization

Connection Pooling

Pipeline Operations

Memory Optimization

🌍 Redis Cluster Support

📈 Monitoring & Metrics

Redis INFO Command

Custom Metrics

Redis Monitor

☁️ Cloud Redis Services

Azure Cache for Redis

AWS ElastiCache

Google Cloud Memorystore

🔐 Security Best Practices

Authentication

Encryption

Network Security

🔧 Troubleshooting

Common Issues

📋 Requirements

📚 Documentation & Support

📄 License