# Ubuntu/Debian
sudo apt-get update
sudo apt-get install redis-server

# macOS
brew install redis

# Start Redis
sudo systemctl start redis    # Linux
brew services start redis     # macOS

# Verify
redis-cli ping
# Should return: PONG

# redis-cli included with server install
# For scripts, use redis-cli directly

# Test connection
redis-cli set test "hello"
redis-cli get test
# Returns: hello

redis-cli del test

#!/bin/bash

# =============================================================================
# ⚡ Redis Helper Functions for OpenClaw
# =============================================================================

# Default Redis connection
REDIS_HOST="${REDIS_HOST:-localhost}"
REDIS_PORT="${REDIS_PORT:-6379}"

# =============================================================================
# 🔧 CORE FUNCTIONS
# =============================================================================

# Set a key with optional TTL (Time To Live in seconds)
redis_set() {
    local key="$1"
    local value="$2"
    local ttl="${3:-}"
    
    if [ -n "$ttl" ]; then
        redis-cli -h "$REDIS_HOST" -p "$REDIS_PORT" setex "$key" "$ttl" "$value" >/dev/null
    else
        redis-cli -h "$REDIS_HOST" -p "$REDIS_PORT" set "$key" "$value" >/dev/null
    fi
}

# Get a key value
redis_get() {
    local key="$1"
    redis-cli -h "$REDIS_HOST" -p "$REDIS_PORT" get "$key"
}

# Delete a key
redis_delete() {
    local key="$1"
    redis-cli -h "$REDIS_HOST" -p "$REDIS_PORT" del "$key" >/dev/null
}

# Check if key exists (returns 1 if exists, 0 if not)
redis_exists() {
    local key="$1"
    redis-cli -h "$REDIS_HOST" -p "$REDIS_PORT" exists "$key"
}

# Get TTL of a key (returns seconds remaining, -1 if no TTL, -2 if not exists)
redis_ttl() {
    local key="$1"
    redis-cli -h "$REDIS_HOST" -p "$REDIS_PORT" ttl "$key"
}

# List keys matching pattern (default: all)
redis_keys() {
    local pattern="${1:-*}"
    redis-cli -h "$REDIS_HOST" -p "$REDIS_PORT" keys "$pattern"
}

# =============================================================================
# 🎯 CONVENIENCE FUNCTIONS
# =============================================================================

# Cache JSON data with TTL
redis_cache_json() {
    local key="$1"
    local json_data="$2"
    local ttl="${3:-300}"  # Default 5 minutes
    
    # Compress JSON to single line
    local compressed
    compressed=$(echo "$json_data" | jq -c . 2>/dev/null || echo "$json_data")
    
    redis_set "$key" "$compressed" "$ttl"
}

# Get and parse cached JSON
redis_get_json() {
    local key="$1"
    local value
    value=$(redis_get "$key")
    
    if [ -n "$value" ] && [ "$value" != "nil" ]; then
        echo "$value" | jq . 2>/dev/null || echo "$value"
    else
        echo "null"
    fi
}

# Cache with automatic expiration for different data types
redis_cache_weather() {
    local location="$1"
    local data="$2"
    # Cache weather for 30 minutes
    redis_cache_json "weather:$location" "$data" 1800
}

redis_cache_price() {
    local item="$1"
    local data="$2"
    # Cache prices for 5 minutes
    redis_cache_json "price:$item" "$data" 300
}

redis_cache_health() {
    local service="$1"
    local data="$2"
    # Cache health for 1 minute
    redis_cache_json "health:$service" "$data" 60
}

redis_cache_session() {
    local session_id="$1"
    local data="$2"
    # Cache sessions for 1 hour
    redis_cache_json "session:$session_id" "$data" 3600
}

# =============================================================================
# 📊 MONITORING FUNCTIONS
# =============================================================================

# Show cache statistics
redis_stats() {
    echo "📊 Redis Statistics"
    echo "=================="
    
    # Memory usage
    echo -n "Memory Used: "
    redis-cli -h "$REDIS_HOST" -p "$REDIS_PORT" info memory | grep "used_memory_human" | cut -d: -f2
    
    # Number of keys
    echo -n "Total Keys: "
    redis-cli -h "$REDIS_HOST" -p "$REDIS_PORT" dbsize
    
    # Connected clients
    echo -n "Connected Clients: "
    redis-cli -h "$REDIS_HOST" -p "$REDIS_PORT" info clients | grep "connected_clients" | cut -d: -f2
}

# Clear all cache (use with caution!)
redis_flush() {
    echo "⚠️  This will delete ALL cached data!"
    read -p "Type 'yes' to confirm: " confirm
    
    if [ "$confirm" = "yes" ]; then
        redis-cli -h "$REDIS_HOST" -p "$REDIS_PORT" flushdb
        echo "✅ Cache cleared"
    else
        echo "❌ Cancelled"
    fi
}

# Show keys by prefix
redis_list_by_prefix() {
    local prefix="$1"
    echo "🔑 Keys with prefix '$prefix':"
    redis_keys "${prefix}*" | while read -r key; do
        local ttl
        ttl=$(redis_ttl "$key")
        printf "  %-40s (TTL: %s)\n" "$key" "$ttl"
    done
}

chmod +x ~/scripts/redis-utils.sh

#!/bin/bash

source ~/scripts/redis-utils.sh

fetch_gold_price() {
    local cache_key="price:gold:xauusd"
    
    # 1. Check cache first
    local cached
    cached=$(redis_get_json "$cache_key")
    
    if [ "$cached" != "null" ]; then
        echo "💰 Cache HIT! Gold price (cached):"
        echo "$cached" | jq -r '.price'
        return 0
    fi
    
    echo "🔄 Cache MISS — Fetching from API..."
    
    # 2. Fetch from external API
    local api_response
    api_response=$(curl -s "https://api.goldapi.io/v1/XAU/USD" \
        -H "x-access-token: YOUR_API_KEY")
    
    # 3. Parse and format
    local price
    price=$(echo "$api_response" | jq -r '.price')
    
    local formatted_data
    formatted_data=$(jq -n \
        --arg price "$price" \
        --arg time "$(date -Iseconds)" \
        '{price: $price, timestamp: $time, source: "goldapi"}')
    
    # 4. Store in cache (5 minutes)
    redis_cache_price "gold:xauusd" "$formatted_data"
    
    echo "💰 Gold price (fresh): $price"
    echo "✅ Cached for 5 minutes"
}

# Run
fetch_gold_price

#!/bin/bash

source ~/scripts/redis-utils.sh

fetch_weather() {
    local city="${1:-Jakarta}"
    local cache_key="weather:$city"
    
    # Check cache
    local cached
    cached=$(redis_get_json "$cache_key")
    
    if [ "$cached" != "null" ]; then
        echo "🌤️  Weather for $city (cached):"
        echo "$cached" | jq -r '.condition, .temperature'
        return 0
    fi
    
    echo "🔄 Fetching weather for $city..."
    
    # API call (example)
    local weather_data
    weather_data=$(curl -s "https://api.weather.com/v1/current?city=$city" \
        -H "Authorization: Bearer YOUR_KEY")
    
    # Cache for 30 minutes
    redis_cache_weather "$city" "$weather_data"
    
    echo "🌤️  Weather for $city:"
    echo "$weather_data" | jq -r '.condition, .temperature'
}

fetch_weather "Singapore"

#!/bin/bash

source ~/scripts/redis-utils.sh

check_service_health() {
    local service="$1"
    local url="$2"
    local cache_key="health:$service"
    
    # Check cache first (1 minute TTL)
    local cached
    cached=$(redis_get_json "$cache_key")
    
    if [ "$cached" != "null" ]; then
        local status
        status=$(echo "$cached" | jq -r '.status')
        echo "[$service] $status (cached)"
        return 0
    fi
    
    # Check service
    local start_time end_time duration
    start_time=$(date +%s%N)
    
    if curl -s --max-time 5 "$url" >/dev/null 2>&1; then
        end_time=$(date +%s%N)
        duration=$(( (end_time - start_time) / 1000000 ))
        
        local result
        result=$(jq -n \
            --arg status "UP" \
            --argjson response_time "$duration" \
            --arg checked_at "$(date -Iseconds)" \
            '{status: $status, response_time: $response_time, checked_at: $checked_at}')
        
        redis_cache_health "$service" "$result"
        echo "[$service] UP (${duration}ms)"
    else
        local result
        result=$(jq -n \
            --arg status "DOWN" \
            --arg checked_at "$(date -Iseconds)" \
            '{status: $status, checked_at: $checked_at}')
        
        redis_cache_health "$service" "$result"
        echo "[$service] DOWN"
    fi
}

# Check multiple services
echo "🏥 Health Check (with caching):"
check_service_health "api" "https://api.example.com/health"
check_service_health "database" "https://db.example.com/ping"
check_service_health "website" "https://example.com"

#!/bin/bash

source ~/scripts/redis-utils.sh

# Store user session
save_session() {
    local session_id="$1"
    local user_data="$2"
    
    redis_cache_session "$session_id" "$user_data"
    echo "✅ Session saved (1 hour)"
}

# Retrieve user session
get_session() {
    local session_id="$1"
    local session_data
    
    session_data=$(redis_get_json "session:$session_id")
    
    if [ "$session_data" != "null" ]; then
        echo "$session_data"
    else
        echo "{}"
    fi
}

# Example usage
user_session='{"user_id": "123", "name": "Alex", "preferences": {"theme": "dark"}}'
save_session "sess_abc123" "$user_session"

retrieved=$(get_session "sess_abc123")
echo "User: $(echo "$retrieved" | jq -r '.name')"

#!/bin/bash

source ~/scripts/redis-utils.sh

# =============================================================================
# ⚡ Generic Cached API Caller
# =============================================================================

cached_api_call() {
    local cache_key="$1"
    local api_url="$2"
    local cache_seconds="${3:-300}"  # Default 5 minutes
    local api_headers="${4:-}"
    
    echo "🔍 Checking cache for: $cache_key"
    
    # Try cache first
    local cached_data
    cached_data=$(redis_get_json "$cache_key")
    
    if [ "$cached_data" != "null" ]; then
        local cache_age
        cache_age=$(redis_ttl "$cache_key")
        echo "✅ Cache HIT! (expires in ${cache_age}s)"
        echo "$cached_data"
        return 0
    fi
    
    echo "🔄 Cache miss — calling API..."
    
    # Make API call
    local response
    if [ -n "$api_headers" ]; then
        response=$(curl -s -H "$api_headers" "$api_url")
    else
        response=$(curl -s "$api_url")
    fi
    
    # Validate response (simple JSON check)
    if ! echo "$response" | jq -e . >/dev/null 2>&1; then
        echo "❌ Invalid API response" >&2
        return 1
    fi
    
    # Cache the response
    redis_cache_json "$cache_key" "$response" "$cache_seconds"
    echo "✅ Cached for ${cache_seconds} seconds"
    
    echo "$response"
}

# Example usage
echo "Fetching data with caching..."
result=$(cached_api_call "users:list" "https://jsonplaceholder.typicode.com/users" 600)
echo "$result" | jq '.[0].name'

#!/bin/bash

source ~/scripts/redis-utils.sh

API_URL="https://api.example.com/data"
CACHE_KEY="perf:test"

echo "🚀 Performance Test: Cached vs Non-Cached"
echo "=========================================="

# Test 1: Non-cached
echo -e "\n❌ Without Cache:"
for i in 1 2 3; do
    redis_delete "$CACHE_KEY"  # Clear cache
    
    start=$(date +%s%N)
    curl -s "$API_URL" > /dev/null
    end=$(date +%s%N)
    
    duration=$(( (end - start) / 1000000 ))
    echo "  Request $i: ${duration}ms"
done

# Test 2: Cached
echo -e "\n✅ With Cache:"
# Pre-populate cache
cached_api_call "$CACHE_KEY" "$API_URL" 300 >/dev/null

for i in 1 2 3; do
    start=$(date +%s%N)
    redis_get "$CACHE_KEY" > /dev/null
    end=$(date +%s%N)
    
    duration=$(( (end - start) / 1000000 ))
    echo "  Request $i: ${duration}ms"
done

# Good: Hierarchical, descriptive
cache_key="weather:singapore:daily"
cache_key="user:123:profile"
cache_key="api:github:rate_limit"

# Bad: Vague, collision-prone
cache_key="data"
cache_key="temp"

fetch_with_cache() {
    local key="$1"
    local url="$2"
    
    # Try cache first
    local cached
    cached=$(redis_get_json "$key")
    
    if [ "$cached" != "null" ]; then
        echo "$cached"
        return 0
    fi
    
    # Fetch with error handling
    local response
    response=$(curl -s --max-time 10 "$url")
    
    if [ $? -ne 0 ] || [ -z "$response" ]; then
        # Return stale cache if available (optional)
        echo "⚠️  API failed, no cache" >&2
        return 1
    fi
    
    # Cache successful response
    redis_cache_json "$key" "$response" 300
    echo "$response"
}

# Pre-populate cache before peak hours
warm_cache() {
    echo "🔥 Warming cache..."
    
    # Pre-fetch common data
    cached_api_call "config:main" "$API_BASE/config" 3600 >/dev/null
    cached_api_call "users:top" "$API_BASE/users/top" 300 >/dev/null
    cached_api_call "prices:all" "$API_BASE/prices" 300 >/dev/null
    
    echo "✅ Cache warmed"
}

# Run on cron at 8 AM
0 8 * * * ~/scripts/warm-cache.sh

# Check status
sudo systemctl status redis

# Start Redis
sudo systemctl start redis

# Auto-start on boot
sudo systemctl enable redis

# Check Redis is listening
netstat -tlnp | grep 6379

# Check firewall
sudo ufw allow 6379  # If needed locally

# Check memory usage
redis-cli info memory

# Set max memory in redis.conf
maxmemory 256mb
maxmemory-policy allkeys-lru  # Evict least recently used