from dataclasses import dataclass
from typing import List, Dict, Optional, Tuple
from enum import Enum
import json
import yaml

class ServiceType(Enum):
    BUSINESS = "business"
    INFRASTRUCTURE = "infrastructure"
    GATEWAY = "gateway"
    DATA = "data"

class CommunicationPattern(Enum):
    SYNCHRONOUS = "synchronous"
    ASYNCHRONOUS = "asynchronous"
    EVENT_DRIVEN = "event_driven"

@dataclass
class ServiceDefinition:
    name: str
    type: ServiceType
    responsibilities: List[str]
    dependencies: List[str]
    data_stores: List[str]
    communication_patterns: List[CommunicationPattern]
    scalability_requirements: Dict[str, any]
    
@dataclass
class ArchitectureRecommendation:
    service_count: int
    complexity_score: float
    recommended_patterns: List[str]
    technology_stack: Dict[str, str]
    deployment_strategy: str
    estimated_cost: Dict[str, float]

class MicroservicesArchitectureAnalyzer:
    def __init__(self):
        self.services = []
        self.domain_boundaries = {}
        
    def analyze_domain(self, business_capabilities: List[str], 
                      data_entities: List[str],
                      user_journeys: List[str]) -> Dict[str, any]:
        """分析业务域，识别服务边界"""
        
        # 基于业务能力分析
        capability_groups = self._group_capabilities(business_capabilities)
        
        # 基于数据实体分析
        data_clusters = self._cluster_data_entities(data_entities)
        
        # 基于用户旅程分析
        journey_flows = self._analyze_user_journeys(user_journeys)
        
        # 生成服务建议
        service_recommendations = self._generate_service_recommendations(
            capability_groups, data_clusters, journey_flows
        )
        
        return {
            "capability_groups": capability_groups,
            "data_clusters": data_clusters,
            "journey_flows": journey_flows,
            "service_recommendations": service_recommendations,
            "complexity_analysis": self._calculate_complexity(service_recommendations)
        }
    
    def _group_capabilities(self, capabilities: List[str]) -> Dict[str, List[str]]:
        """基于业务能力分组"""
        groups = {
            "user_management": [],
            "order_processing": [],
            "payment_handling": [],
            "inventory_management": [],
            "notification_services": [],
            "analytics_reporting": []
        }
        
        capability_mapping = {
            "user": "user_management",
            "auth": "user_management",
            "order": "order_processing",
            "cart": "order_processing",
            "payment": "payment_handling",
            "billing": "payment_handling",
            "inventory": "inventory_management",
            "product": "inventory_management",
            "notification": "notification_services",
            "email": "notification_services",
            "analytics": "analytics_reporting",
            "report": "analytics_reporting"
        }
        
        for capability in capabilities:
            for keyword, group in capability_mapping.items():
                if keyword in capability.lower():
                    groups[group].append(capability)
                    break
        
        return {k: v for k, v in groups.items() if v}
    
    def _cluster_data_entities(self, entities: List[str]) -> Dict[str, List[str]]:
        """基于数据实体聚类"""
        clusters = {}
        
        # 简化的聚类逻辑
        entity_relationships = {
            "user": ["profile", "preference", "authentication"],
            "order": ["item", "shipping", "status"],
            "product": ["catalog", "inventory", "pricing"],
            "payment": ["transaction", "billing", "refund"]
        }
        
        for entity in entities:
            for cluster_key, related_entities in entity_relationships.items():
                if any(related in entity.lower() for related in related_entities):
                    if cluster_key not in clusters:
                        clusters[cluster_key] = []
                    clusters[cluster_key].append(entity)
                    break
        
        return clusters
    
    def _analyze_user_journeys(self, journeys: List[str]) -> Dict[str, List[str]]:
        """分析用户旅程"""
        flows = {}
        
        for journey in journeys:
            # 简化的旅程分析
            if "registration" in journey.lower():
                flows["user_onboarding"] = ["authentication", "profile_creation", "verification"]
            elif "purchase" in journey.lower():
                flows["purchase_flow"] = ["product_search", "cart_management", "payment", "order_fulfillment"]
            elif "support" in journey.lower():
                flows["customer_support"] = ["ticket_creation", "communication", "resolution"]
        
        return flows
    
    def _generate_service_recommendations(self, capability_groups: Dict, 
                                        data_clusters: Dict, 
                                        journey_flows: Dict) -> List[ServiceDefinition]:
        """生成服务建议"""
        services = []
        
        # 基于能力组生成服务
        for group_name, capabilities in capability_groups.items():
            service = ServiceDefinition(
                name=f"{group_name}_service",
                type=ServiceType.BUSINESS,
                responsibilities=capabilities,
                dependencies=[],
                data_stores=[group_name + "_db"],
                communication_patterns=[CommunicationPattern.SYNCHRONOUS],
                scalability_requirements={"min_instances": 2, "max_instances": 10}
            )
            services.append(service)
        
        # 添加基础设施服务
        infrastructure_services = [
            ServiceDefinition(
                name="api_gateway",
                type=ServiceType.GATEWAY,
                responsibilities=["request_routing", "authentication", "rate_limiting"],
                dependencies=[],
                data_stores=["gateway_cache"],
                communication_patterns=[CommunicationPattern.SYNCHRONOUS],
                scalability_requirements={"min_instances": 3, "max_instances": 20}
            ),
            ServiceDefinition(
                name="event_bus",
                type=ServiceType.INFRASTRUCTURE,
                responsibilities=["event_routing", "message_persistence", "delivery_guarantee"],
                dependencies=[],
                data_stores=["event_store"],
                communication_patterns=[CommunicationPattern.ASYNCHRONOUS],
                scalability_requirements={"min_instances": 3, "max_instances": 15}
            )
        ]
        
        services.extend(infrastructure_services)
        return services
    
    def _calculate_complexity(self, services: List[ServiceDefinition]) -> Dict[str, any]:
        """计算架构复杂度"""
        service_count = len(services)
        
        # 计算复杂度分数
        complexity_factors = {
            "service_count": service_count * 0.3,
            "communication_complexity": sum(len(s.dependencies) for s in services) * 0.4,
            "data_complexity": sum(len(s.data_stores) for s in services) * 0.3
        }
        
        total_complexity = sum(complexity_factors.values())
        
        return {
            "total_score": total_complexity,
            "factors": complexity_factors,
            "recommendation": self._get_complexity_recommendation(total_complexity)
        }
    
    def _get_complexity_recommendation(self, score: float) -> str:
        """基于复杂度分数提供建议"""
        if score < 10:
            return "低复杂度：适合小团队，建议从简单的服务拆分开始"
        elif score < 25:
            return "中等复杂度：需要完善的DevOps流程和监控体系"
        else:
            return "高复杂度：需要专业的微服务治理平台和经验丰富的团队"
    
    def generate_architecture_blueprint(self, services: List[ServiceDefinition]) -> Dict[str, any]:
        """生成架构蓝图"""
        blueprint = {
            "version": "1.0",
            "services": {},
            "communication_matrix": {},
            "deployment_topology": {},
            "monitoring_strategy": {}
        }
        
        # 服务定义
        for service in services:
            blueprint["services"][service.name] = {
                "type": service.type.value,
                "responsibilities": service.responsibilities,
                "dependencies": service.dependencies,
                "data_stores": service.data_stores,
                "scaling": service.scalability_requirements
            }
        
        # 通信矩阵
        blueprint["communication_matrix"] = self._build_communication_matrix(services)
        
        # 部署拓扑
        blueprint["deployment_topology"] = self._design_deployment_topology(services)
        
        # 监控策略
        blueprint["monitoring_strategy"] = self._design_monitoring_strategy(services)
        
        return blueprint
    
    def _build_communication_matrix(self, services: List[ServiceDefinition]) -> Dict[str, Dict[str, str]]:
        """构建服务通信矩阵"""
        matrix = {}
        
        for service in services:
            matrix[service.name] = {}
            for dep in service.dependencies:
                # 简化的通信模式推断
                if service.type == ServiceType.GATEWAY:
                    matrix[service.name][dep] = "http_sync"
                elif "event" in dep:
                    matrix[service.name][dep] = "event_async"
                else:
                    matrix[service.name][dep] = "http_sync"
        
        return matrix
    
    def _design_deployment_topology(self, services: List[ServiceDefinition]) -> Dict[str, any]:
        """设计部署拓扑"""
        topology = {
            "clusters": {
                "production": {
                    "nodes": 6,
                    "node_type": "m5.large",
                    "availability_zones": 3
                },
                "staging": {
                    "nodes": 3,
                    "node_type": "m5.medium",
                    "availability_zones": 2
                }
            },
            "namespaces": {
                "gateway": ["api_gateway"],
                "business": [s.name for s in services if s.type == ServiceType.BUSINESS],
                "infrastructure": [s.name for s in services if s.type == ServiceType.INFRASTRUCTURE],
                "data": [s.name for s in services if s.type == ServiceType.DATA]
            },
            "ingress": {
                "load_balancer": "nginx",
                "ssl_termination": True,
                "rate_limiting": True
            }
        }
        
        return topology
    
    def _design_monitoring_strategy(self, services: List[ServiceDefinition]) -> Dict[str, any]:
        """设计监控策略"""
        strategy = {
            "metrics": {
                "application": ["request_rate", "error_rate", "response_time"],
                "infrastructure": ["cpu_usage", "memory_usage", "disk_io"],
                "business": ["transaction_volume", "user_activity", "revenue_metrics"]
            },
            "logging": {
                "centralized": True,
                "structured": True,
                "retention_days": 30
            },
            "tracing": {
                "distributed": True,
                "sampling_rate": 0.1,
                "trace_retention_hours": 72
            },
            "alerting": {
                "sla_violations": True,
                "error_rate_threshold": 0.05,
                "response_time_threshold": "2s"
            }
        }
        
        return strategy

# 使用示例
def microservices_analysis_example():
    analyzer = MicroservicesArchitectureAnalyzer()
    
    # 业务能力
    business_capabilities = [
        "User Registration", "User Authentication", "User Profile Management",
        "Product Catalog", "Inventory Management", "Order Processing",
        "Payment Processing", "Shipping Management", "Notification Service",
        "Analytics and Reporting", "Customer Support"
    ]
    
    # 数据实体
    data_entities = [
        "User", "UserProfile", "Product", "Category", "Inventory",
        "Order", "OrderItem", "Payment", "Transaction", "Shipment",
        "Notification", "Report", "SupportTicket"
    ]
    
    # 用户旅程
    user_journeys = [
        "User Registration and Onboarding",
        "Product Discovery and Purchase",
        "Order Tracking and Support",
        "Account Management"
    ]
    
    # 分析域
    analysis_result = analyzer.analyze_domain(
        business_capabilities, data_entities, user_journeys
    )
    
    print("=== 微服务架构分析结果 ===")
    print(f"识别的能力组: {list(analysis_result['capability_groups'].keys())}")
    print(f"数据聚类: {list(analysis_result['data_clusters'].keys())}")
    print(f"用户旅程: {list(analysis_result['journey_flows'].keys())}")
    print(f"复杂度分析: {analysis_result['complexity_analysis']['recommendation']}")
    
    # 生成架构蓝图
    services = analysis_result['service_recommendations']
    blueprint = analyzer.generate_architecture_blueprint(services)
    
    print(f"\n=== 架构蓝图 ===")
    print(f"服务数量: {len(blueprint['services'])}")
    print(f"部署集群: {list(blueprint['deployment_topology']['clusters'].keys())}")
    print(f"监控指标: {blueprint['monitoring_strategy']['metrics']['application']}")
    
    return analysis_result, blueprint

if __name__ == "__main__":
    microservices_analysis_example()

from abc import ABC, abstractmethod
from typing import List, Dict, Any, Optional
from dataclasses import dataclass, field
from enum import Enum
import uuid

class BoundedContextType(Enum):
    CORE = "core"
    SUPPORTING = "supporting"
    GENERIC = "generic"

@dataclass
class DomainEvent:
    event_id: str = field(default_factory=lambda: str(uuid.uuid4()))
    event_type: str = ""
    aggregate_id: str = ""
    version: int = 1
    timestamp: str = ""
    data: Dict[str, Any] = field(default_factory=dict)

class AggregateRoot(ABC):
    def __init__(self, aggregate_id: str):
        self.aggregate_id = aggregate_id
        self.version = 0
        self.uncommitted_events: List[DomainEvent] = []
    
    def mark_events_as_committed(self):
        self.uncommitted_events.clear()
    
    def get_uncommitted_events(self) -> List[DomainEvent]:
        return self.uncommitted_events.copy()
    
    def apply_event(self, event: DomainEvent):
        self.uncommitted_events.append(event)
        self.version += 1

@dataclass
class BoundedContext:
    name: str
    type: BoundedContextType
    domain_services: List[str]
    aggregates: List[str]
    value_objects: List[str]
    repositories: List[str]
    domain_events: List[str]
    integration_events: List[str]
    
class ServiceDecompositionStrategy:
    def __init__(self):
        self.bounded_contexts = {}
        self.context_map = {}
    
    def define_bounded_context(self, context: BoundedContext):
        """定义限界上下文"""
        self.bounded_contexts[context.name] = context
        
    def analyze_context_relationships(self) -> Dict[str, Dict[str, str]]:
        """分析上下文关系"""
        relationships = {}
        
        # 定义上下文间的关系模式
        relationship_patterns = {
            ("user_management", "order_processing"): "customer_supplier",
            ("order_processing", "payment_processing"): "partnership",
            ("order_processing", "inventory_management"): "shared_kernel",
            ("notification_service", "order_processing"): "conformist",
            ("analytics", "order_processing"): "anticorruption_layer"
        }
        
        for (upstream, downstream), pattern in relationship_patterns.items():
            if upstream not in relationships:
                relationships[upstream] = {}
            relationships[upstream][downstream] = pattern
            
        return relationships
    
    def generate_service_boundaries(self) -> Dict[str, Dict[str, Any]]:
        """生成服务边界"""
        service_boundaries = {}
        
        for context_name, context in self.bounded_contexts.items():
            # 基于聚合根确定服务边界
            if context.type == BoundedContextType.CORE:
                # 核心域：每个聚合一个服务
                for aggregate in context.aggregates:
                    service_name = f"{context_name}_{aggregate}_service"
                    service_boundaries[service_name] = {
                        "bounded_context": context_name,
                        "primary_aggregate": aggregate,
                        "responsibilities": [aggregate],
                        "data_ownership": [aggregate.lower() + "_data"],
                        "api_contracts": self._generate_api_contract(aggregate),
                        "integration_patterns": ["event_sourcing", "cqrs"]
                    }
            else:
                # 支撑域和通用域：可以合并多个聚合
                service_name = f"{context_name}_service"
                service_boundaries[service_name] = {
                    "bounded_context": context_name,
                    "aggregates": context.aggregates,
                    "responsibilities": context.aggregates,
                    "data_ownership": [agg.lower() + "_data" for agg in context.aggregates],
                    "api_contracts": self._generate_composite_api_contract(context.aggregates),
                    "integration_patterns": ["crud", "shared_database"]
                }
        
        return service_boundaries
    
    def _generate_api_contract(self, aggregate: str) -> Dict[str, List[str]]:
        """生成API契约"""
        base_operations = ["create", "update", "delete", "get", "list"]
        
        return {
            "commands": [f"{op}_{aggregate}" for op in base_operations[:3]],
            "queries": [f"{op}_{aggregate}" for op in base_operations[3:]],
            "events": [f"{aggregate}_created", f"{aggregate}_updated", f"{aggregate}_deleted"]
        }
    
    def _generate_composite_api_contract(self, aggregates: List[str]) -> Dict[str, List[str]]:
        """生成复合API契约"""
        commands = []
        queries = []
        events = []
        
        for aggregate in aggregates:
            contract = self._generate_api_contract(aggregate)
            commands.extend(contract["commands"])
            queries.extend(contract["queries"])
            events.extend(contract["events"])
        
        return {
            "commands": commands,
            "queries": queries,
            "events": events
        }
    
    def validate_service_design(self, service_boundaries: Dict[str, Dict[str, Any]]) -> Dict[str, List[str]]:
        """验证服务设计"""
        validation_results = {
            "warnings": [],
            "recommendations": [],
            "violations": []
        }
        
        # 检查服务数量
        service_count = len(service_boundaries)
        if service_count > 20:
            validation_results["warnings"].append(f"服务数量过多({service_count})，可能导致管理复杂度过高")
        elif service_count < 3:
            validation_results["warnings"].append(f"服务数量过少({service_count})，可能未充分利用微服务优势")
        
        # 检查数据所有权
        data_ownership = {}
        for service_name, service_info in service_boundaries.items():
            for data in service_info.get("data_ownership", []):
                if data in data_ownership:
                    validation_results["violations"].append(
                        f"数据所有权冲突: {data} 被 {service_name} 和 {data_ownership[data]} 同时拥有"
                    )
                data_ownership[data] = service_name
        
        # 检查API设计
        for service_name, service_info in service_boundaries.items():
            api_contract = service_info.get("api_contracts", {})
            if not api_contract.get("events"):
                validation_results["recommendations"].append(
                    f"{service_name} 缺少领域事件，建议添加事件发布机制"
                )
        
        return validation_results

# 使用示例
def service_decomposition_example():
    strategy = ServiceDecompositionStrategy()
    
    # 定义限界上下文
    contexts = [
        BoundedContext(
            name="user_management",
            type=BoundedContextType.CORE,
            domain_services=["UserService", "AuthenticationService"],
            aggregates=["User", "UserProfile"],
            value_objects=["Email", "Password"],
            repositories=["UserRepository"],
            domain_events=["UserRegistered", "UserProfileUpdated"],
            integration_events=["UserCreated", "UserActivated"]
        ),
        BoundedContext(
            name="order_processing",
            type=BoundedContextType.CORE,
            domain_services=["OrderService", "OrderValidationService"],
            aggregates=["Order", "OrderItem"],
            value_objects=["Money", "Quantity"],
            repositories=["OrderRepository"],
            domain_events=["OrderPlaced", "OrderShipped"],
            integration_events=["OrderCreated", "OrderCompleted"]
        ),
        BoundedContext(
            name="payment_processing",
            type=BoundedContextType.SUPPORTING,
            domain_services=["PaymentService"],
            aggregates=["Payment", "Transaction"],
            value_objects=["CreditCard", "Amount"],
            repositories=["PaymentRepository"],
            domain_events=["PaymentProcessed", "PaymentFailed"],
            integration_events=["PaymentCompleted", "RefundIssued"]
        )
    ]
    
    # 注册上下文
    for context in contexts:
        strategy.define_bounded_context(context)
    
    # 分析关系
    relationships = strategy.analyze_context_relationships()
    print("=== 上下文关系分析 ===")
    for upstream, downstreams in relationships.items():
        for downstream, pattern in downstreams.items():
            print(f"{upstream} -> {downstream}: {pattern}")
    
    # 生成服务边界
    service_boundaries = strategy.generate_service_boundaries()
    print(f"\n=== 服务边界设计 ===")
    for service_name, service_info in service_boundaries.items():
        print(f"\n服务: {service_name}")
        print(f"  限界上下文: {service_info['bounded_context']}")
        print(f"  职责: {service_info['responsibilities']}")
        print(f"  数据所有权: {service_info['data_ownership']}")
    
    # 验证设计
    validation = strategy.validate_service_design(service_boundaries)
    print(f"\n=== 设计验证 ===")
    if validation["violations"]:
        print("违规项:")
        for violation in validation["violations"]:
            print(f"  - {violation}")
    
    if validation["warnings"]:
        print("警告项:")
        for warning in validation["warnings"]:
            print(f"  - {warning}")
    
    if validation["recommendations"]:
        print("建议项:")
        for recommendation in validation["recommendations"]:
            print(f"  - {recommendation}")
    
    return service_boundaries, validation

if __name__ == "__main__":
    service_decomposition_example()

import yaml
from typing import Dict, List, Any, Optional
from dataclasses import dataclass
from enum import Enum

class DeploymentStrategy(Enum):
    ROLLING_UPDATE = "RollingUpdate"
    RECREATE = "Recreate"
    BLUE_GREEN = "BlueGreen"
    CANARY = "Canary"

class ServiceType(Enum):
    CLUSTER_IP = "ClusterIP"
    NODE_PORT = "NodePort"
    LOAD_BALANCER = "LoadBalancer"

@dataclass
class ResourceRequirements:
    cpu_request: str = "100m"
    cpu_limit: str = "500m"
    memory_request: str = "128Mi"
    memory_limit: str = "512Mi"

@dataclass
class HealthCheck:
    path: str = "/health"
    port: int = 8080
    initial_delay: int = 30
    period: int = 10
    timeout: int = 5
    failure_threshold: int = 3

class KubernetesManifestGenerator:
    def __init__(self):
        self.namespace = "microservices"
        self.app_version = "v1.0.0"
    
    def generate_namespace(self) -> Dict[str, Any]:
        """生成命名空间配置"""
        return {
            "apiVersion": "v1",
            "kind": "Namespace",
            "metadata": {
                "name": self.namespace,
                "labels": {
                    "name": self.namespace,
                    "environment": "production"
                }
            }
        }
    
    def generate_deployment(self, 
                          service_name: str,
                          image: str,
                          replicas: int = 3,
                          resources: ResourceRequirements = None,
                          health_check: HealthCheck = None,
                          env_vars: Dict[str, str] = None,
                          strategy: DeploymentStrategy = DeploymentStrategy.ROLLING_UPDATE) -> Dict[str, Any]:
        """生成Deployment配置"""
        
        if resources is None:
            resources = ResourceRequirements()
        
        if health_check is None:
            health_check = HealthCheck()
        
        if env_vars is None:
            env_vars = {}
        
        deployment = {
            "apiVersion": "apps/v1",
            "kind": "Deployment",
            "metadata": {
                "name": service_name,
                "namespace": self.namespace,
                "labels": {
                    "app": service_name,
                    "version": self.app_version
                }
            },
            "spec": {
                "replicas": replicas,
                "strategy": {
                    "type": strategy.value
                },
                "selector": {
                    "matchLabels": {
                        "app": service_name
                    }
                },
                "template": {
                    "metadata": {
                        "labels": {
                            "app": service_name,
                            "version": self.app_version
                        }
                    },
                    "spec": {
                        "containers": [{
                            "name": service_name,
                            "image": image,
                            "ports": [{
                                "containerPort": health_check.port,
                                "name": "http"
                            }],
                            "env": [{"name": k, "value": v} for k, v in env_vars.items()],
                            "resources": {
                                "requests": {
                                    "cpu": resources.cpu_request,
                                    "memory": resources.memory_request
                                },
                                "limits": {
                                    "cpu": resources.cpu_limit,
                                    "memory": resources.memory_limit
                                }
                            },
                            "livenessProbe": {
                                "httpGet": {
                                    "path": health_check.path,
                                    "port": health_check.port
                                },
                                "initialDelaySeconds": health_check.initial_delay,
                                "periodSeconds": health_check.period,
                                "timeoutSeconds": health_check.timeout,
                                "failureThreshold": health_check.failure_threshold
                            },
                            "readinessProbe": {
                                "httpGet": {
                                    "path": health_check.path,
                                    "port": health_check.port
                                },
                                "initialDelaySeconds": 10,
                                "periodSeconds": 5,
                                "timeoutSeconds": health_check.timeout,
                                "failureThreshold": 2
                            }
                        }]
                    }
                }
            }
        }
        
        # 添加滚动更新策略配置
        if strategy == DeploymentStrategy.ROLLING_UPDATE:
            deployment["spec"]["strategy"]["rollingUpdate"] = {
                "maxUnavailable": "25%",
                "maxSurge": "25%"
            }
        
        return deployment
    
    def generate_service(self, 
                        service_name: str,
                        port: int = 80,
                        target_port: int = 8080,
                        service_type: ServiceType = ServiceType.CLUSTER_IP) -> Dict[str, Any]:
        """生成Service配置"""
        
        service = {
            "apiVersion": "v1",
            "kind": "Service",
            "metadata": {
                "name": service_name,
                "namespace": self.namespace,
                "labels": {
                    "app": service_name
                }
            },
            "spec": {
                "type": service_type.value,
                "ports": [{
                    "port": port,
                    "targetPort": target_port,
                    "protocol": "TCP",
                    "name": "http"
                }],
                "selector": {
                    "app": service_name
                }
            }
        }
        
        return service
    
    def generate_configmap(self, 
                          name: str,
                          data: Dict[str, str]) -> Dict[str, Any]:
        """生成ConfigMap配置"""
        
        return {
            "apiVersion": "v1",
            "kind": "ConfigMap",
            "metadata": {
                "name": name,
                "namespace": self.namespace
            },
            "data": data
        }
    
    def generate_secret(self, 
                       name: str,
                       data: Dict[str, str]) -> Dict[str, Any]:
        """生成Secret配置"""
        
        import base64
        
        # 对数据进行base64编码
        encoded_data = {k: base64.b64encode(v.encode()).decode() for k, v in data.items()}
        
        return {
            "apiVersion": "v1",
            "kind": "Secret",
            "metadata": {
                "name": name,
                "namespace": self.namespace
            },
            "type": "Opaque",
            "data": encoded_data
        }
    
    def generate_hpa(self, 
                     service_name: str,
                     min_replicas: int = 2,
                     max_replicas: int = 10,
                     cpu_threshold: int = 70) -> Dict[str, Any]:
        """生成HorizontalPodAutoscaler配置"""
        
        return {
            "apiVersion": "autoscaling/v2",
            "kind": "HorizontalPodAutoscaler",
            "metadata": {
                "name": f"{service_name}-hpa",
                "namespace": self.namespace
            },
            "spec": {
                "scaleTargetRef": {
                    "apiVersion": "apps/v1",
                    "kind": "Deployment",
                    "name": service_name
                },
                "minReplicas": min_replicas,
                "maxReplicas": max_replicas,
                "metrics": [{
                    "type": "Resource",
                    "resource": {
                        "name": "cpu",
                        "target": {
                            "type": "Utilization",
                            "averageUtilization": cpu_threshold
                        }
                    }
                }]
            }
        }
    
    def generate_ingress(self, 
                        name: str,
                        rules: List[Dict[str, Any]],
                        tls_enabled: bool = True) -> Dict[str, Any]:
        """生成Ingress配置"""
        
        ingress = {
            "apiVersion": "networking.k8s.io/v1",
            "kind": "Ingress",
            "metadata": {
                "name": name,
                "namespace": self.namespace,
                "annotations": {
                    "nginx.ingress.kubernetes.io/rewrite-target": "/",
                    "nginx.ingress.kubernetes.io/ssl-redirect": "true" if tls_enabled else "false"
                }
            },
            "spec": {
                "ingressClassName": "nginx",
                "rules": rules
            }
        }
        
        if tls_enabled:
            ingress["spec"]["tls"] = [{
                "hosts": [rule["host"] for rule in rules if "host" in rule],
                "secretName": f"{name}-tls"
            }]
        
        return ingress
    
    def generate_complete_manifest(self, service_configs: List[Dict[str, Any]]) -> str:
        """生成完整的Kubernetes清单"""
        
        manifests = []
        
        # 添加命名空间
        manifests.append(self.generate_namespace())
        
        # 为每个服务生成配置
        for config in service_configs:
            service_name = config["name"]
            image = config["image"]
            
            # Deployment
            deployment = self.generate_deployment(
                service_name=service_name,
                image=image,
                replicas=config.get("replicas", 3),
                resources=config.get("resources"),
                health_check=config.get("health_check"),
                env_vars=config.get("env_vars", {})
            )
            manifests.append(deployment)
            
            # Service
            service = self.generate_service(
                service_name=service_name,
                port=config.get("port", 80),
                target_port=config.get("target_port", 8080)
            )
            manifests.append(service)
            
            # HPA
            if config.get("auto_scaling", True):
                hpa = self.generate_hpa(
                    service_name=service_name,
                    min_replicas=config.get("min_replicas", 2),
                    max_replicas=config.get("max_replicas", 10)
                )
                manifests.append(hpa)
            
            # ConfigMap
            if config.get("config_data"):
                configmap = self.generate_configmap(
                    name=f"{service_name}-config",
                    data=config["config_data"]
                )
                manifests.append(configmap)
            
            # Secret
            if config.get("secret_data"):
                secret = self.generate_secret(
                    name=f"{service_name}-secret",
                    data=config["secret_data"]
                )
                manifests.append(secret)
        
        # 生成Ingress
        ingress_rules = []
        for config in service_configs:
            if config.get("external_access"):
                ingress_rules.append({
                    "host": config.get("host", f"{config['name']}.example.com"),
                    "http": {
                        "paths": [{
                            "path": config.get("path", "/"),
                            "pathType": "Prefix",
                            "backend": {
                                "service": {
                                    "name": config["name"],
                                    "port": {
                                        "number": config.get("port", 80)
                                    }
                                }
                            }
                        }]
                    }
                })
        
        if ingress_rules:
            ingress = self.generate_ingress(
                name="microservices-ingress",
                rules=ingress_rules
            )
            manifests.append(ingress)
        
        # 转换为YAML
        yaml_content = ""
        for manifest in manifests:
            yaml_content += "---\n"
            yaml_content += yaml.dump(manifest, default_flow_style=False, allow_unicode=True)
            yaml_content += "\n"
        
        return yaml_content

# 使用示例
def kubernetes_deployment_example():
    generator = KubernetesManifestGenerator()
    
    # 定义服务配置
    service_configs = [
        {
            "name": "user-service",
            "image": "myregistry/user-service:v1.0.0",
            "replicas": 3,
            "port": 80,
            "target_port": 8080,
            "external_access": True,
            "host": "api.example.com",
            "path": "/users",
            "resources": ResourceRequirements(
                cpu_request="200m",
                cpu_limit="1000m",
                memory_request="256Mi",
                memory_limit="1Gi"
            ),
            "health_check": HealthCheck(
                path="/health",
                port=8080
            ),
            "env_vars": {
                "SPRING_PROFILES_ACTIVE": "production",
                "DATABASE_URL": "postgresql://db:5432/userdb"
            },
            "config_data": {
                "application.yml": """
server:
  port: 8080
spring:
  datasource:
    url: ${DATABASE_URL}
    username: ${DB_USERNAME}
    password: ${DB_PASSWORD}
logging:
  level:
    com.example: INFO
                """.strip()
            },
            "secret_data": {
                "DB_USERNAME": "user_service",
                "DB_PASSWORD": "secure_password_123"
            }
        },
        {
            "name": "order-service",
            "image": "myregistry/order-service:v1.0.0",
            "replicas": 5,
            "port": 80,
            "target_port": 8080,
            "external_access": True,
            "host": "api.example.com",
            "path": "/orders",
            "min_replicas": 3,
            "max_replicas": 15,
            "env_vars": {
                "SPRING_PROFILES_ACTIVE": "production",
                "KAFKA_BROKERS": "kafka:9092"
            }
        },
        {
            "name": "payment-service",
            "image": "myregistry/payment-service:v1.0.0",
            "replicas": 2,
            "port": 80,
            "target_port": 8080,
            "external_access": False,
            "env_vars": {
                "PAYMENT_GATEWAY_URL": "https://payment-gateway.example.com",
                "ENCRYPTION_KEY": "payment_encryption_key"
            }
        }
    ]
    
    # 生成完整清单
    manifest_yaml = generator.generate_complete_manifest(service_configs)
    
    print("=== Kubernetes部署清单 ===")
    print(manifest_yaml)
    
    # 保存到文件
    with open("microservices-deployment.yaml", "w", encoding="utf-8") as f:
        f.write(manifest_yaml)
    
    print("清单已保存到 microservices-deployment.yaml")
    
    return manifest_yaml

if __name__ == "__main__":
    kubernetes_deployment_example()

import yaml
from typing import Dict, List, Any, Optional
from dataclasses import dataclass
from enum import Enum

class TrafficPolicy(Enum):
    ROUND_ROBIN = "ROUND_ROBIN"
    LEAST_CONN = "LEAST_CONN"
    RANDOM = "RANDOM"
    PASSTHROUGH = "PASSTHROUGH"

class TLSMode(Enum):
    DISABLE = "DISABLE"
    SIMPLE = "SIMPLE"
    MUTUAL = "MUTUAL"
    ISTIO_MUTUAL = "ISTIO_MUTUAL"

@dataclass
class CircuitBreakerConfig:
    consecutive_errors: int = 5
    interval: str = "30s"
    base_ejection_time: str = "30s"
    max_ejection_percent: int = 50

@dataclass
class RetryConfig:
    attempts: int = 3
    per_try_timeout: str = "2s"
    retry_on: str = "5xx,reset,connect-failure,refused-stream"

class IstioServiceMeshManager:
    def __init__(self, namespace: str = "microservices"):
        self.namespace = namespace
    
    def generate_virtual_service(self, 
                                service_name: str,
                                hosts: List[str],
                                routes: List[Dict[str, Any]],
                                fault_injection: Optional[Dict[str, Any]] = None,
                                timeout: Optional[str] = None,
                                retry: Optional[RetryConfig] = None) -> Dict[str, Any]:
        """生成VirtualService配置"""
        
        virtual_service = {
            "apiVersion": "networking.istio.io/v1beta1",
            "kind": "VirtualService",
            "metadata": {
                "name": f"{service_name}-vs",
                "namespace": self.namespace
            },
            "spec": {
                "hosts": hosts,
                "http": []
            }
        }
        
        for route in routes:
            http_route = {
                "match": route.get("match", [{"uri": {"prefix": "/"}}]),
                "route": route["destinations"]
            }
            
            # 添加超时配置
            if timeout:
                http_route["timeout"] = timeout
            
            # 添加重试配置
            if retry:
                http_route["retries"] = {
                    "attempts": retry.attempts,
                    "perTryTimeout": retry.per_try_timeout,
                    "retryOn": retry.retry_on
                }
            
            # 添加故障注入
            if fault_injection:
                http_route["fault"] = fault_injection
            
            virtual_service["spec"]["http"].append(http_route)
        
        return virtual_service
    
    def generate_destination_rule(self, 
                                 service_name: str,
                                 host: str,
                                 traffic_policy: TrafficPolicy = TrafficPolicy.ROUND_ROBIN,
                                 circuit_breaker: Optional[CircuitBreakerConfig] = None,
                                 tls_mode: TLSMode = TLSMode.ISTIO_MUTUAL,
                                 subsets: Optional[List[Dict[str, Any]]] = None) -> Dict[str, Any]:
        """生成DestinationRule配置"""
        
        destination_rule = {
            "apiVersion": "networking.istio.io/v1beta1",
            "kind": "DestinationRule",
            "metadata": {
                "name": f"{service_name}-dr",
                "namespace": self.namespace
            },
            "spec": {
                "host": host,
                "trafficPolicy": {
                    "loadBalancer": {
                        "simple": traffic_policy.value
                    },
                    "tls": {
                        "mode": tls_mode.value
                    }
                }
            }
        }
        
        # 添加熔断器配置
        if circuit_breaker:
            destination_rule["spec"]["trafficPolicy"]["outlierDetection"] = {
                "consecutiveErrors": circuit_breaker.consecutive_errors,
                "interval": circuit_breaker.interval,
                "baseEjectionTime": circuit_breaker.base_ejection_time,
                "maxEjectionPercent": circuit_breaker.max_ejection_percent
            }
        
        # 添加子集配置（用于金丝雀部署）
        if subsets:
            destination_rule["spec"]["subsets"] = subsets
        
        return destination_rule
    
    def generate_gateway(self, 
                        name: str,
                        hosts: List[str],
                        port: int = 80,
                        https_port: int = 443,
                        tls_enabled: bool = True) -> Dict[str, Any]:
        """生成Gateway配置"""
        
        servers = [{
            "port": {
                "number": port,
                "name": "http",
                "protocol": "HTTP"
            },
            "hosts": hosts
        }]
        
        if tls_enabled:
            servers.append({
                "port": {
                    "number": https_port,
                    "name": "https",
                    "protocol": "HTTPS"
                },
                "tls": {
                    "mode": "SIMPLE",
                    "credentialName": f"{name}-tls"
                },
                "hosts": hosts
            })
        
        return {
            "apiVersion": "networking.istio.io/v1beta1",
            "kind": "Gateway",
            "metadata": {
                "name": name,
                "namespace": self.namespace
            },
            "spec": {
                "selector": {
                    "istio": "ingressgateway"
                },
                "servers": servers
            }
        }
    
    def generate_service_entry(self, 
                              name: str,
                              hosts: List[str],
                              ports: List[Dict[str, Any]],
                              location: str = "MESH_EXTERNAL") -> Dict[str, Any]:
        """生成ServiceEntry配置（用于外部服务）"""
        
        return {
            "apiVersion": "networking.istio.io/v1beta1",
            "kind": "ServiceEntry",
            "metadata": {
                "name": name,
                "namespace": self.namespace
            },
            "spec": {
                "hosts": hosts,
                "ports": ports,
                "location": location,
                "resolution": "DNS"
            }
        }
    
    def generate_authorization_policy(self, 
                                    name: str,
                                    selector: Dict[str, str],
                                    rules: List[Dict[str, Any]]) -> Dict[str, Any]:
        """生成AuthorizationPolicy配置"""
        
        return {
            "apiVersion": "security.istio.io/v1beta1",
            "kind": "AuthorizationPolicy",
            "metadata": {
                "name": name,
                "namespace": self.namespace
            },
            "spec": {
                "selector": {
                    "matchLabels": selector
                },
                "rules": rules
            }
        }
    
    def generate_peer_authentication(self, 
                                   name: str,
                                   selector: Optional[Dict[str, str]] = None,
                                   mtls_mode: str = "STRICT") -> Dict[str, Any]:
        """生成PeerAuthentication配置"""
        
        policy = {
            "apiVersion": "security.istio.io/v1beta1",
            "kind": "PeerAuthentication",
            "metadata": {
                "name": name,
                "namespace": self.namespace
            },
            "spec": {
                "mtls": {
                    "mode": mtls_mode
                }
            }
        }
        
        if selector:
            policy["spec"]["selector"] = {
                "matchLabels": selector
            }
        
        return policy
    
    def generate_telemetry_config(self, 
                                 name: str,
                                 metrics_config: Optional[Dict[str, Any]] = None,
                                 tracing_config: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
        """生成Telemetry配置"""
        
        telemetry = {
            "apiVersion": "telemetry.istio.io/v1alpha1",
            "kind": "Telemetry",
            "metadata": {
                "name": name,
                "namespace": self.namespace
            },
            "spec": {}
        }
        
        if metrics_config:
            telemetry["spec"]["metrics"] = [metrics_config]
        
        if tracing_config:
            telemetry["spec"]["tracing"] = [tracing_config]
        
        return telemetry
    
    def generate_canary_deployment_config(self, 
                                        service_name: str,
                                        stable_version: str,
                                        canary_version: str,
                                        canary_weight: int = 10) -> List[Dict[str, Any]]:
        """生成金丝雀部署配置"""
        
        configs = []
        
        # DestinationRule with subsets
        destination_rule = self.generate_destination_rule(
            service_name=service_name,
            host=service_name,
            subsets=[
                {
                    "name": "stable",
                    "labels": {"version": stable_version}
                },
                {
                    "name": "canary",
                    "labels": {"version": canary_version}
                }
            ]
        )
        configs.append(destination_rule)
        
        # VirtualService for traffic splitting
        virtual_service = self.generate_virtual_service(
            service_name=service_name,
            hosts=[service_name],
            routes=[{
                "match": [{"uri": {"prefix": "/"}}],
                "destinations": [
                    {
                        "destination": {
                            "host": service_name,
                            "subset": "stable"
                        },
                        "weight": 100 - canary_weight
                    },
                    {
                        "destination": {
                            "host": service_name,
                            "subset": "canary"
                        },
                        "weight": canary_weight
                    }
                ]
            }]
        )
        configs.append(virtual_service)
        
        return configs
    
    def generate_complete_service_mesh_config(self, services: List[Dict[str, Any]]) -> str:
        """生成完整的服务网格配置"""
        
        manifests = []
        
        # 生成Gateway
        gateway = self.generate_gateway(
            name="microservices-gateway",
            hosts=["api.example.com", "*.example.com"]
        )
        manifests.append(gateway)
        
        # 为每个服务生成配置
        for service in services:
            service_name = service["name"]
            
            # VirtualService
            virtual_service = self.generate_virtual_service(
                service_name=service_name,
                hosts=[f"api.example.com"],
                routes=[{
                    "match": [{"uri": {"prefix": service.get("path", f"/{service_name}")}}],
                    "destinations": [{
                        "destination": {
                            "host": service_name,
                            "port": {"number": service.get("port", 80)}
                        }
                    }]
                }],
                timeout=service.get("timeout", "30s"),
                retry=RetryConfig(
                    attempts=service.get("retry_attempts", 3),
                    per_try_timeout=service.get("per_try_timeout", "2s")
                )
            )
            manifests.append(virtual_service)
            
            # DestinationRule
            destination_rule = self.generate_destination_rule(
                service_name=service_name,
                host=service_name,
                traffic_policy=TrafficPolicy.ROUND_ROBIN,
                circuit_breaker=CircuitBreakerConfig(
                    consecutive_errors=service.get("circuit_breaker_errors", 5),
                    interval="30s",
                    base_ejection_time="30s",
                    max_ejection_percent=50
                )
            )
            manifests.append(destination_rule)
            
            # Authorization Policy
            if service.get("auth_required", True):
                auth_policy = self.generate_authorization_policy(
                    name=f"{service_name}-auth",
                    selector={"app": service_name},
                    rules=[{
                        "from": [{
                            "source": {
                                "principals": ["cluster.local/ns/istio-system/sa/istio-ingressgateway-service-account"]
                            }
                        }],
                        "to": [{
                            "operation": {
                                "methods": ["GET", "POST", "PUT", "DELETE"]
                            }
                        }]
                    }]
                )
                manifests.append(auth_policy)
        
        # 全局mTLS策略
        peer_auth = self.generate_peer_authentication(
            name="default",
            mtls_mode="STRICT"
        )
        manifests.append(peer_auth)
        
        # 遥测配置
        telemetry = self.generate_telemetry_config(
            name="default-metrics",
            metrics_config={
                "providers": [{
                    "name": "prometheus"
                }]
            },
            tracing_config={
                "providers": [{
                    "name": "jaeger"
                }]
            }
        )
        manifests.append(telemetry)
        
        # 转换为YAML
        yaml_content = ""
        for manifest in manifests:
            yaml_content += "---\n"
            yaml_content += yaml.dump(manifest, default_flow_style=False, allow_unicode=True)
            yaml_content += "\n"
        
        return yaml_content

# 使用示例
def istio_service_mesh_example():
    mesh_manager = IstioServiceMeshManager()
    
    # 定义服务配置
    services = [
        {
            "name": "user-service",
            "path": "/users",
            "port": 80,
            "timeout": "10s",
            "retry_attempts": 3,
            "per_try_timeout": "3s",
            "circuit_breaker_errors": 5,
            "auth_required": True
        },
        {
            "name": "order-service",
            "path": "/orders",
            "port": 80,
            "timeout": "15s",
            "retry_attempts": 2,
            "per_try_timeout": "5s",
            "circuit_breaker_errors": 3,
            "auth_required": True
        },
        {
            "name": "payment-service",
            "path": "/payments",
            "port": 80,
            "timeout": "20s",
            "retry_attempts": 5,
            "per_try_timeout": "4s",
            "circuit_breaker_errors": 2,
            "auth_required": True
        }
    ]
    
    # 生成完整配置
    mesh_config = mesh_manager.generate_complete_service_mesh_config(services)
    
    print("=== Istio服务网格配置 ===")
    print(mesh_config)
    
    # 生成金丝雀部署示例
    print("\n=== 金丝雀部署配置示例 ===")
    canary_configs = mesh_manager.generate_canary_deployment_config(
        service_name="user-service",
        stable_version="v1.0.0",
        canary_version="v1.1.0",
        canary_weight=20
    )
    
    for config in canary_configs:
        print("---")
        print(yaml.dump(config, default_flow_style=False, allow_unicode=True))
    
    # 保存配置
    with open("istio-service-mesh.yaml", "w", encoding="utf-8") as f:
        f.write(mesh_config)
    
    print("服务网格配置已保存到 istio-service-mesh.yaml")
    
    return mesh_config

if __name__ == "__main__":
    istio_service_mesh_example()