How to Implement a Weighted DNS Resolver with Failover in Python

import random
import time

class WeightedDNSResolver:
    def __init__(self, records):
        self.records = records  # list of (ip, weight)
        self.total_weight = sum(weight for _, weight in records)
        self.failed_ips = set()

    def resolve(self):
        available = [(ip, weight) for ip, weight in self.records if ip not in self.failed_ips]
        if not available:
            return None
        
        total = sum(weight for _, weight in available)
        rand = random.uniform(0, total)
        cumulative = 0
        
        for ip, weight in available:
            cumulative += weight
            if rand <= cumulative:
                return ip

    def mark_failed(self, ip):
        self.failed_ips.add(ip)

    def simulate_traffic(self, num_requests=10):
        results = {}
        for _ in range(num_requests):
            ip = self.resolve()
            if ip:
                results[ip] = results.get(ip, 0) + 1
                if random.random() < 0.2:
                    self.mark_failed(ip)
            time.sleep(0.01)
        return results

if __name__ == "__main__":
    records = [("192.168.1.10", 50), ("192.168.1.11", 30), ("192.168.1.12", 20)]
    resolver = WeightedDNSResolver(records)
    
    print("Initial resolution test (10 requests):")
    results = resolver.simulate_traffic(10)
    for ip, count in sorted(results.items(), key=lambda x: -x[1]):
        print(f"  {ip}: {count} requests")
    
    resolver.mark_failed("192.168.1.10")
    print("\nAfter failover (10 more requests, .10 marked failed):")
    results = resolver.simulate_traffic(10)
    for ip, count in sorted(results.items(), key=lambda x: -x[1]):
        print(f"  {ip}: {count} requests")