Multi-Datacenter Circuit Breaker Patterns — Cross-Region Resilience Architecture

import time
import json

class MultiRegionCircuitState:
    def __init__(self):
        self.regions = {}

    def update_region(self, region, service, state, timestamp=None):
        if region not in self.regions:
            self.regions[region] = {}
        self.regions[region][service] = {
            'state': state,
            'timestamp': timestamp or time.time()
        }

    def get_global_state(self, service):
        states = {}
        for region, circuits in self.regions.items():
            if service in circuits:
                states[region] = circuits[service]
        return states

    def get_healthy_regions(self, service):
        healthy = []
        for region, circuits in self.regions.items():
            if service in circuits:
                entry = circuits[service]
                age = time.time() - entry['timestamp']
                if entry['state'] == 'CLOSED' and age < 60:
                    healthy.append(region)
        return healthy

    def should_route_to_region(self, region, service):
        if region not in self.regions:
            return False
        if service not in self.regions[region]:
            return True
        entry = self.regions[region][service]
        age = time.time() - entry['timestamp']
        return entry['state'] == 'CLOSED' and age < 60

state = MultiRegionCircuitState()
state.update_region("us-east-1", "payment-service", "CLOSED", time.time())
state.update_region("eu-west-1", "payment-service", "OPEN", time.time())
state.update_region("ap-southeast-1", "payment-service", "CLOSED", time.time())

print(f"Healthy regions for payment: {state.get_healthy_regions('payment-service')}")
print(f"Route to us-east-1: {state.should_route_to_region('us-east-1', 'payment-service')}")
print(f"Route to eu-west-1: {state.should_route_to_region('eu-west-1', 'payment-service')}")

import time
import json
import threading

class CrossRegionSync:
    def __init__(self, region_name):
        self.region = region_name
        self.local_states = {}
        self.remote_states = {}
        self.lock = threading.Lock()

    def set_local_state(self, service, state):
        with self.lock:
            entry = {
                'region': self.region,
                'service': service,
                'state': state,
                'timestamp': time.time()
            }
            self.local_states[service] = entry
            return entry

    def receive_remote_state(self, region, service, state, timestamp):
        with self.lock:
            key = f"{region}:{service}"
            old = self.remote_states.get(key)
            if old and old['timestamp'] >= timestamp:
                return
            self.remote_states[key] = {
                'region': region,
                'service': service,
                'state': state,
                'timestamp': timestamp
            }
            print(f"[{self.region}] Received: {region}/{service} = {state}")

    def get_all_states(self, service):
        results = []
        with self.lock:
            if service in self.local_states:
                results.append(self.local_states[service])
            for key, entry in self.remote_states.items():
                if entry['service'] == service:
                    results.append(entry)
        return sorted(results, key=lambda x: x['timestamp'], reverse=True)

sync_us = CrossRegionSync("us-east-1")
sync_eu = CrossRegionSync("eu-west-1")

us_entry = sync_us.set_local_state("payment-service", "OPEN")
sync_eu.receive_remote_state("us-east-1", "payment-service", us_entry['state'], us_entry['timestamp'])
sync_eu.set_local_state("payment-service", "CLOSED")

all_states = sync_eu.get_all_states("payment-service")
for s in all_states:
    print(f"  {s['region']}: {s['state']} (age: {time.time() - s['timestamp']:.0f}s)")

import time
import random

class CircuitAwareGeoRouter:
    def __init__(self):
        self.region_health = {}
        self.default_region = "us-east-1"

    def update_region_health(self, region, service, state):
        if region not in self.region_health:
            self.region_health[region] = {}
        self.region_health[region][service] = state

    def get_best_region(self, service, preferred_region=None):
        candidates = []
        for region, services in self.region_health.items():
            service_state = services.get(service, 'CLOSED')
            if service_state == 'CLOSED':
                candidates.append(region)

        if not candidates:
            return None

        if preferred_region and preferred_region in candidates:
            return preferred_region

        return random.choice(candidates)

    def get_routing_plan(self, service):
        plan = {}
        for region, services in self.region_health.items():
            plan[region] = services.get(service, 'CLOSED')
        best = self.get_best_region(service)
        return {'regions': plan, 'recommended': best}

router = CircuitAwareGeoRouter()
router.update_region_health("us-east-1", "payment-service", "OPEN")
router.update_region_health("eu-west-1", "payment-service", "CLOSED")
router.update_region_health("ap-southeast-1", "payment-service", "CLOSED")

plan = router.get_routing_plan("payment-service")
print(f"Routing plan: {plan['regions']}")
print(f"Recommended region: {plan['recommended']}")