# 好的做法：从环境变量读取配置
import os
DATABASE_URL = os.environ.get('DATABASE_URL', 'sqlite:///default.db')
API_KEY = os.environ.get('API_KEY')

# 不好的做法：硬编码配置
DATABASE_URL = "postgresql://user:pass@localhost/mydb"

# 示例 Dockerfile
FROM python:3.11-slim

WORKDIR /app

# 复制依赖文件并安装
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# 复制应用代码
COPY . .

# 暴露端口
EXPOSE 8000

# 启动命令
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

apiVersion: v1
kind: Pod
metadata:
  name: my-app
spec:
  containers:
  - name: app
    image: my-app:latest
    ports:
    - containerPort: 8000

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-app-deployment
spec:
  replicas: 3
  selector:
    matchLabels:
      app: my-app
  template:
    metadata:
      labels:
        app: my-app
    spec:
      containers:
      - name: app
        image: my-app:latest
        ports:
        - containerPort: 8000

apiVersion: v1
kind: Service
metadata:
  name: my-app-service
spec:
  selector:
    app: my-app
  ports:
  - protocol: TCP
    port: 80
    targetPort: 8000
  type: ClusterIP

apiVersion: v1
kind: ConfigMap
metadata:
  name: app-config
data:
  DATABASE_HOST: postgres.default.svc.cluster.local
  LOG_LEVEL: info
---
apiVersion: v1
kind: Secret
metadata:
  name: app-secret
type: Opaque
data:
  DATABASE_PASSWORD: cGFzc3dvcmQxMjM=  # base64 encoded

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: my-app-ingress
spec:
  rules:
  - host: myapp.example.com
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: my-app-service
            port:
              number: 80

// 伪代码示例
class CircuitBreaker {
    private State state = State.CLOSED;
    private int failureCount = 0;
    private final int threshold = 5;
    
    public Response execute(Request request) {
        if (state == State.OPEN) {
            if (shouldTryAgain()) {
                state = State.HALF_OPEN;
            } else {
                throw new CircuitBreakerOpenException();
            }
        }
        
        try {
            Response response = callService(request);
            onSuccess();
            return response;
        } catch (Exception e) {
            onFailure();
            throw e;
        }
    }
    
    private void onSuccess() {
        failureCount = 0;
        state = State.CLOSED;
    }
    
    private void onFailure() {
        failureCount++;
        if (failureCount >= threshold) {
            state = State.OPEN;
        }
    }
}

import time
import random

def retry_with_backoff(func, max_retries=3, base_delay=1.0):
    for attempt in range(max_retries + 1):
        try:
            return func()
        except TemporaryError as e:
            if attempt == max_retries:
                raise
            delay = base_delay * (2 ** attempt) + random.uniform(0, 1)
            time.sleep(delay)

// 设置超时
HttpClient client = HttpClient.newBuilder()
    .connectTimeout(Duration.ofSeconds(5))
    .build();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("http://service/api"))
    .timeout(Duration.ofSeconds(10))
    .GET()
    .build();

public ProductRecommendation getRecommendations(String userId) {
    try {
        return recommendationService.getPersonalized(userId);
    } catch (Exception e) {
        log.warn("Personalized recommendations failed, using fallback", e);
        return recommendationService.getPopular();
    }
}

// 简单的令牌桶实现
class TokenBucket {
    private final int capacity;
    private double tokens;
    private final double refillRate;
    private long lastRefillTime;
    
    public synchronized boolean tryConsume(int count) {
        refill();
        if (tokens >= count) {
            tokens -= count;
            return true;
        }
        return false;
    }
    
    private void refill() {
        long now = System.currentTimeMillis();
        double elapsed = (now - lastRefillTime) / 1000.0;
        tokens = Math.min(capacity, tokens + elapsed * refillRate);
        lastRefillTime = now;
    }
}

客户端 → 限流 → 熔断器 → 重试 → 超时 → 服务
                          ↓
                       降级方案

┌─────────────────────────────────────┐
│           控制平面                    │
│         (Istio / Linkerd)            │
└──────────────┬──────────────────────┘
               │ 配置下发
       ┌───────┼────────┐
       ▼       ▼        ▼
   ┌───────┐ ┌───────┐ ┌───────┐
   │ Sidecar│ │ Sidecar│ │ Sidecar│  ← 数据平面
   │ Proxy  │ │ Proxy  │ │ Proxy  │
   └───┬───┘ └───┬───┘ └───┬───┘
       │         │         │
   ┌───▼───┐ ┌───▼───┐ ┌───▼───┐
   │Service│ │Service│ │Service│
   │   A   │ │   B   │ │   C   │
   └───────┘ └───────┘ └───────┘

# Istio VirtualService 示例
apiVersion: networking.istio.io/v1beta1
kind: VirtualService
metadata:
  name: my-service
spec:
  hosts:
  - my-service
  http:
  - route:
    - destination:
        host: my-service
        subset: v1
      weight: 90
    - destination:
        host: my-service
        subset: v2
      weight: 10

# Dockerfile 定义了不可变的镜像
FROM node:18-alpine
WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production
COPY . .
EXPOSE 3000
CMD ["node", "server.js"]

# Terraform 定义不可变的基础设施
resource "aws_instance" "web" {
  ami           = var.ami_id  # 镜像 ID，变更时替换
  instance_type = "t3.medium"
  
  user_data = <<-EOF
              #!/bin/bash
              echo "Hello from ${var.environment}"
              EOF
  
  tags = {
    Name = "web-server"
    Environment = var.environment
  }
}

# ArgoCD Application 定义
apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: my-app
spec:
  source:
    repoURL: https://github.com/myorg/my-app.git
    targetRevision: HEAD
    path: k8s
  destination:
    server: https://kubernetes.default.svc
    namespace: production
  syncPolicy:
    automated:
      prune: true
      selfHeal: true

{
  "eventType": "OrderCreated",
  "orderId": "ORD-123",
  "timestamp": "2024-01-15T10:30:00Z"
}

{
  "eventType": "OrderCreated",
  "orderId": "ORD-123",
  "customerId": "CUST-456",
  "items": [
    {"productId": "PROD-1", "quantity": 2, "price": 29.99}
  ],
  "totalAmount": 59.98,
  "timestamp": "2024-01-15T10:30:00Z"
}

OrderCreated → ItemAdded → ItemRemoved → OrderConfirmed

// AWS Lambda 函数示例
exports.handler = async (event) => {
    const orderId = event.orderId;
    
    // 查询订单
    const order = await getOrderFromDatabase(orderId);
    
    // 发送确认邮件
    await sendConfirmationEmail(order);
    
    return {
        statusCode: 200,
        body: JSON.stringify({ message: "Order confirmed" })
    };
};

/**
 * 弹性模式综合示例
 * 展示熔断器、重试、超时、降级、限流的组合使用
 */

package com.example.resilient;

import io.github.resilience4j.circuitbreaker.CircuitBreaker;
import io.github.resilience4j.circuitbreaker.CircuitBreakerConfig;
import io.github.resilience4j.retry.Retry;
import io.github.resilience4j.retry.RetryConfig;
import io.github.resilience4j.timelimiter.TimeLimiter;
import io.github.resilience4j.bulkhead.Bulkhead;
import io.github.resilience4j.bulkhead.BulkheadConfig;
import io.github.resilience4j.ratelimiter.RateLimiter;
import io.github.resilience4j.ratelimiter.RateLimiterConfig;

import java.time.Duration;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;

public class ResilientServiceClient {
    
    private final ExternalService externalService;
    private final CircuitBreaker circuitBreaker;
    private final Retry retry;
    private final TimeLimiter timeLimiter;
    private final Bulkhead bulkhead;
    private final RateLimiter rateLimiter;
    
    public ResilientServiceClient(ExternalService externalService) {
        this.externalService = externalService;
        
        // 配置熔断器
        CircuitBreakerConfig cbConfig = CircuitBreakerConfig.custom()
                .failureRateThreshold(50)  // 失败率阈值 50%
                .waitDurationInOpenState(Duration.ofSeconds(30))  // 熔断持续时间
                .slidingWindowSize(10)  // 滑动窗口大小
                .minimumNumberOfCalls(5)  // 最小调用数
                .build();
        this.circuitBreaker = CircuitBreaker.of("externalService", cbConfig);
        
        // 配置重试
        RetryConfig retryConfig = RetryConfig.custom()
                .maxAttempts(3)  // 最大重试次数
                .waitDuration(Duration.ofMillis(500))  // 基础等待时间
                .enableExponentialBackoff()  // 启用指数退避
                .exponentialBackoffMultiplier(2)  // 退避倍数
                .retryExceptions(ServiceUnavailableException.class, TimeoutException.class)  // 可重试异常
                .build();
        this.retry = Retry.of("externalService", retryConfig);
        
        // 配置超时
        this.timeLimiter = TimeLimiter.of(Duration.ofSeconds(5));
        
        // 配置舱壁
        BulkheadConfig bulkheadConfig = BulkheadConfig.custom()
                .maxConcurrentCalls(10)  // 最大并发调用数
                .maxWaitDuration(Duration.ofMillis(100))  // 最大等待时间
                .build();
        this.bulkhead = Bulkhead.of("externalService", bulkheadConfig);
        
        // 配置限流
        RateLimiterConfig rateLimiterConfig = RateLimiterConfig.custom()
                .limitForPeriod(100)  // 每个周期允许的请求数
                .limitRefreshPeriod(Duration.ofSeconds(1))  // 周期
                .timeoutDuration(Duration.ofMillis(50))  // 获取许可的超时时间
                .build();
        this.rateLimiter = RateLimiter.of("externalService", rateLimiterConfig);
    }
    
    /**
     * 调用外部服务，应用所有弹性模式
     */
    public Response callExternalService(Request request) {
        // 1. 限流：检查是否超过速率限制
        if (!rateLimiter.acquirePermission()) {
            throw new RateLimitExceededException("Rate limit exceeded");
        }
        
        // 2. 舱壁：限制并发调用数
        Bulkhead.decorateSupplier(bulkhead, () -> {
            // 3. 熔断器：检查熔断状态
            return CircuitBreaker.decorateSupplier(circuitBreaker, () -> {
                // 4. 超时：限制执行时间
                return TimeLimiter.decorateFutureSupplier(timeLimiter, () -> {
                    // 5. 重试：失败时重试
                    return Retry.decorateSupplier(retry, () -> {
                        try {
                            return externalService.call(request);
                        } catch (ServiceUnavailableException e) {
                            // 记录日志，抛出异常触发重试
                            throw new RuntimeException(e);
                        }
                    }).get();
                });
            });
        }).get();
    }
    
    /**
     * 带降级的调用
     */
    public Response callWithFallback(Request request) {
        try {
            return callExternalService(request);
        } catch (Exception e) {
            // 记录日志
            log.warn("External service call failed, using fallback", e);
            
            // 降级方案：返回缓存数据或默认值
            return getFallbackResponse(request);
        }
    }
    
    private Response getFallbackResponse(Request request) {
        // 尝试从缓存获取
        Response cached = cache.get(request.getKey());
        if (cached != null) {
            return cached;
        }
        
        // 返回默认响应
        return Response.defaultResponse();
    }
}

"""
事件驱动架构示例

展示事件的发布、订阅和处理，以及事件溯源模式
"""

from dataclasses import dataclass, field
from typing import List, Dict, Any, Callable
from datetime import datetime
from enum import Enum
import json
import uuid
import threading
from abc import ABC, abstractmethod


# ==================== 事件定义 ====================

class EventType(Enum):
    """事件类型枚举"""
    ORDER_CREATED = "order_created"
    ORDER_CONFIRMED = "order_confirmed"
    ORDER_SHIPPED = "order_shipped"
    ORDER_DELIVERED = "order_delivered"
    ORDER_CANCELLED = "order_cancelled"
    PAYMENT_PROCESSED = "payment_processed"
    PAYMENT_FAILED = "payment_failed"


@dataclass
class Event:
    """事件基类"""
    event_id: str = field(default_factory=lambda: str(uuid.uuid4()))
    event_type: EventType = None
    timestamp: str = field(default_factory=lambda: datetime.utcnow().isoformat())
    source: str = ""  # 事件来源
    data: Dict[str, Any] = field(default_factory=dict)
    version: int = 1  # 事件版本
    
    def to_dict(self) -> dict:
        return {
            "event_id": self.event_id,
            "event_type": self.event_type.value,
            "timestamp": self.timestamp,
            "source": self.source,
            "data": self.data,
            "version": self.version
        }
    
    def to_json(self) -> str:
        return json.dumps(self.to_dict())
    
    @classmethod
    def from_dict(cls, data: dict) -> 'Event':
        return cls(
            event_id=data["event_id"],
            event_type=EventType(data["event_type"]),
            timestamp=data["timestamp"],
            source=data["source"],
            data=data["data"],
            version=data.get("version", 1)
        )


@dataclass
class OrderCreatedEvent(Event):
    """订单创建事件"""
    def __post_init__(self):
        self.event_type = EventType.ORDER_CREATED


@dataclass
class PaymentProcessedEvent(Event):
    """支付处理事件"""
    def __post_init__(self):
        self.event_type = EventType.PAYMENT_PROCESSED


@dataclass
class OrderShippedEvent(Event):
    """订单发货事件"""
    def __post_init__(self):
        self.event_type = EventType.ORDER_SHIPPED


# ==================== 事件总线 ====================

class EventBus(ABC):
    """事件总线抽象"""
    
    @abstractmethod
    def publish(self, event: Event) -> None:
        """发布事件"""
        pass
    
    @abstractmethod
    def subscribe(self, event_type: EventType, handler: Callable[[Event], None]) -> None:
        """订阅事件"""
        pass


class InMemoryEventBus(EventBus):
    """内存事件总线实现（用于演示）"""
    
    def __init__(self):
        self._subscribers: Dict[EventType, List[Callable]] = {}
        self._event_store: List[Event] = []  # 事件存储
        self._lock = threading.Lock()
    
    def publish(self, event: Event) -> None:
        """发布事件到所有订阅者"""
        with self._lock:
            # 存储事件（事件溯源）
            self._event_store.append(event)
            
            # 通知订阅者
            subscribers = self._subscribers.get(event.event_type, [])
            for handler in subscribers:
                try:
                    handler(event)
                except Exception as e:
                    print(f"Handler error: {e}")
    
    def subscribe(self, event_type: EventType, handler: Callable[[Event], None]) -> None:
        """注册事件处理器"""
        if event_type not in self._subscribers:
            self._subscribers[event_type] = []
        self._subscribers[event_type].append(handler)
    
    def get_events(self, event_type: EventType = None) -> List[Event]:
        """获取历史事件"""
        if event_type:
            return [e for e in self._event_store if e.event_type == event_type]
        return self._event_store.copy()


# ==================== 事件处理器 ====================

class PaymentProcessor:
    """支付处理器 - 订阅订单创建事件"""
    
    def __init__(self, event_bus: EventBus):
        self.event_bus = event_bus
        # 订阅订单创建事件
        event_bus.subscribe(EventType.ORDER_CREATED, self.handle_order_created)
    
    def handle_order_created(self, event: Event) -> None:
        """处理订单创建事件"""
        print(f"PaymentProcessor: Processing payment for order {event.data.get('order_id')}")
        
        # 模拟支付处理
        order_id = event.data["order_id"]
        amount = event.data["total_amount"]
        
        # 这里会调用支付网关
        payment_success = True  # 模拟成功
        
        if payment_success:
            payment_event = PaymentProcessedEvent(
                source="payment_processor",
                data={
                    "order_id": order_id,
                    "amount": amount,
                    "status": "success"
                }
            )
            self.event_bus.publish(payment_event)
            print(f"PaymentProcessor: Payment successful for order {order_id}")
        else:
            # 支付失败事件
            pass


class ShippingService:
    """物流服务 - 订阅支付成功事件"""
    
    def __init__(self, event_bus: EventBus):
        self.event_bus = event_bus
        # 订阅支付成功事件
        event_bus.subscribe(EventType.PAYMENT_PROCESSED, self.handle_payment_processed)
    
    def handle_payment_processed(self, event: Event) -> None:
        """处理支付成功事件"""
        if event.data.get("status") == "success":
            order_id = event.data["order_id"]
            print(f"ShippingService: Preparing shipment for order {order_id}")
            
            # 模拟发货
            shipping_event = OrderShippedEvent(
                source="shipping_service",
                data={
                    "order_id": order_id,
                    "tracking_number": f"TRK-{uuid.uuid4().hex[:8].upper()}",
                    "carrier": "FedEx"
                }
            )
            self.event_bus.publish(shipping_event)
            print(f"ShippingService: Order {order_id} shipped")


class NotificationService:
    """通知服务 - 订阅多种事件"""
    
    def __init__(self, event_bus: EventBus):
        self.event_bus = event_bus
        # 订阅多种事件
        event_bus.subscribe(EventType.ORDER_CREATED, self.handle_order_created)
        event_bus.subscribe(EventType.ORDER_SHIPPED, self.handle_order_shipped)
    
    def handle_order_created(self, event: Event) -> None:
        """发送订单创建通知"""
        order_id = event.data.get("order_id")
        print(f"NotificationService: Sending confirmation email for order {order_id}")
    
    def handle_order_shipped(self, event: Event) -> None:
        """发送发货通知"""
        order_id = event.data.get("order_id")
        tracking = event.data.get("tracking_number")
        print(f"NotificationService: Sending shipping notification for order {order_id}, tracking: {tracking}")


# ==================== 事件溯源：订单状态重建 ====================

class OrderProjection:
    """订单投影 - 从事件重建订单状态"""
    
    def __init__(self, event_bus: EventBus):
        self.event_bus = event_bus
        self.orders: Dict[str, Dict[str, Any]] = {}
    
    def rebuild_from_events(self, events: List[Event]) -> None:
        """从事件列表重建订单状态"""
        for event in events:
            self.apply_event(event)
    
    def apply_event(self, event: Event) -> None:
        """应用单个事件"""
        order_id = event.data.get("order_id")
        if not order_id:
            return
        
        if order_id not in self.orders:
            self.orders[order_id] = {"order_id": order_id, "events": []}
        
        order = self.orders[order_id]
        
        if event.event_type == EventType.ORDER_CREATED:
            order["status"] = "created"
            order["customer_id"] = event.data.get("customer_id")
            order["total_amount"] = event.data.get("total_amount")
        
        elif event.event_type == EventType.PAYMENT_PROCESSED:
            if event.data.get("status") == "success":
                order["status"] = "paid"
                order["payment_info"] = event.data
        
        elif event.event_type == EventType.ORDER_SHIPPED:
            order["status"] = "shipped"
            order["tracking_number"] = event.data.get("tracking_number")
        
        elif event.event_type == EventType.ORDER_DELIVERED:
            order["status"] = "delivered"
        
        elif event.event_type == EventType.ORDER_CANCELLED:
            order["status"] = "cancelled"
        
        order["events"].append(event.to_dict())
    
    def get_order_status(self, order_id: str) -> Dict[str, Any]:
        """获取订单当前状态"""
        return self.orders.get(order_id, {})


# ==================== 测试 ====================

def test_event_driven_architecture():
    """测试事件驱动架构"""
    print("\n===== 测试事件驱动架构 =====")
    
    # 创建事件总线
    event_bus = InMemoryEventBus()
    
    # 创建服务
    payment_processor = PaymentProcessor(event_bus)
    shipping_service = ShippingService(event_bus)
    notification_service = NotificationService(event_bus)
    
    # 创建订单投影
    projection = OrderProjection(event_bus)
    
    # 发布订单创建事件
    order_event = OrderCreatedEvent(
        source="order_service",
        data={
            "order_id": "ORD-001",
            "customer_id": "CUST-123",
            "total_amount": 99.99,
            "items": [
                {"product_id": "PROD-1", "quantity": 1, "price": 99.99}
            ]
        }
    )
    
    print("Publishing OrderCreated event...")
    event_bus.publish(order_event)
    
    # 查看事件存储
    print(f"\nTotal events stored: {len(event_bus.get_events())}")
    
    # 重建订单状态
    projection.rebuild_from_events(event_bus.get_events())
    order_status = projection.get_order_status("ORD-001")
    print(f"\nOrder status after events: {order_status.get('status')}")
    print(f"Tracking number: {order_status.get('tracking_number', 'N/A')}")


if __name__ == "__main__":
    test_event_driven_architecture()