我来分析 Kubernetes 1.35.3 中 test/compatibility_lifecycle/main.go 的源码。这个文件是 Kubernetes 兼容性生命周期测试工具的核心实现。

文件位置与作用

test/compatibility_lifecycle/main.go 是 Kubernetes 版本兼容性测试工具，用于验证不同 Kubernetes 版本之间的 API 兼容性。

核心功能分析

1. 主要结构体

// CompatibilityLifecycleTester 是主要的测试结构体
type CompatibilityLifecycleTester struct {
    // 存储不同版本的API信息
    versions map[string]*VersionInfo
    
    // 兼容性配置
    config *CompatibilityConfig
}

// VersionInfo 存储单个版本的信息
type VersionInfo struct {
    Version   string           // 版本号
    APIs      map[string]APIInfo // API信息
    Deprecated []string        // 已弃用的API
    Removed    []string        // 已移除的API
}

// CompatibilityConfig 定义兼容性规则
type CompatibilityConfig struct {
    MinVersion string   // 最低支持版本
    MaxVersion string   // 最高支持版本
    SkipAPIs   []string // 跳过的API
}

2. 主要工作流程

func main() {
    // 1. 解析命令行参数
    flags := parseFlags()
    
    // 2. 初始化测试器
    tester := NewCompatibilityLifecycleTester(flags)
    
    // 3. 收集API信息
    if err := tester.collectAPIs(); err != nil {
        log.Fatal(err)
    }
    
    // 4. 执行兼容性检查
    if err := tester.runCompatibilityChecks(); err != nil {
        log.Fatal(err)
    }
    
    // 5. 生成报告
    if err := tester.generateReport(); err != nil {
        log.Fatal(err)
    }
}

3. API 收集机制

func (t *CompatibilityLifecycleTester) collectAPIs() error {
    // 获取所有需要测试的版本
    versions := t.getVersions()
    
    for _, version := range versions {
        // 构建API发现客户端
        client, err := t.createDiscoveryClient(version)
        if err != nil {
            return fmt.Errorf("failed to create client for %s: %v", version, err)
        }
        
        // 发现API组和资源
        apiGroups, err := client.ServerGroups()
        if err != nil {
            return err
        }
        
        // 处理每个API组
        for _, group := range apiGroups.Groups {
            for _, version := range group.Versions {
                resources, err := client.ServerResourcesForGroupVersion(version.GroupVersion)
                if err != nil {
                    continue
                }
                
                // 存储API信息
                t.storeAPIInfo(version.GroupVersion, resources)
            }
        }
    }
    return nil
}

4. 兼容性检查核心逻辑

func (t *CompatibilityLifecycleTester) runCompatibilityChecks() error {
    var errors []error
    
    // 按版本顺序检查
    versions := t.getSortedVersions()
    
    for i, currentVer := range versions {
        if i == 0 {
            continue // 跳过第一个版本
        }
        
        prevVer := versions[i-1]
        
        // 检查向前兼容性
        if err := t.checkForwardCompatibility(prevVer, currentVer); err != nil {
            errors = append(errors, fmt.Errorf("forward compat %s->%s: %v", 
                prevVer, currentVer, err))
        }
        
        // 检查向后兼容性
        if err := t.checkBackwardCompatibility(currentVer, prevVer); err != nil {
            errors = append(errors, fmt.Errorf("backward compat %s->%s: %v", 
                currentVer, prevVer, err))
        }
        
        // 检查API生命周期
        if err := t.checkAPILifecycle(currentVer, prevVer); err != nil {
            errors = append(errors, fmt.Errorf("lifecycle %s->%s: %v", 
                prevVer, currentVer, err))
        }
    }
    
    if len(errors) > 0 {
        return fmt.Errorf("compatibility checks failed: %v", errors)
    }
    return nil
}

5. API 生命周期验证

func (t *CompatibilityLifecycleTester) checkAPILifecycle(current, prev string) error {
    currentAPIs := t.versions[current].APIs
    prevAPIs := t.versions[prev].APIs
    
    // 检查API移除规则
    for apiName, apiInfo := range prevAPIs {
        if _, exists := currentAPIs[apiName]; !exists {
            // API被移除了，检查是否符合生命周期策略
            if err := t.validateAPIRemoval(apiInfo, prev, current); err != nil {
                return fmt.Errorf("API %s removed incorrectly: %v", apiName, err)
            }
        }
    }
    
    // 检查API弃用规则
    for apiName, apiInfo := range currentAPIs {
        if apiInfo.Deprecated {
            // 检查弃用标注是否正确
            if err := t.validateDeprecation(apiInfo, current); err != nil {
                return fmt.Errorf("API %s deprecation invalid: %v", apiName, err)
            }
        }
    }
    
    return nil
}

6. GA 和 Beta API 规则

func (t *CompatibilityLifecycleTester) validateAPIRemoval(apiInfo APIInfo, fromVer, toVer string) error {
    // GA API 移除规则
    if apiInfo.Stability == "GA" {
        // GA API 至少保留12个月或3个版本
        if !t.meetsGARetentionPolicy(apiInfo, fromVer, toVer) {
            return fmt.Errorf("GA API removed too early")
        }
    }
    
    // Beta API 移除规则
    if apiInfo.Stability == "Beta" {
        // Beta API 至少保留9个月或2个版本
        if !t.meetsBetaRetentionPolicy(apiInfo, fromVer, toVer) {
            return fmt.Errorf("Beta API removed too early")
        }
    }
    
    return nil
}

7. 测试报告生成

func (t *CompatibilityLifecycleTester) generateReport() error {
    report := &CompatibilityReport{
        GeneratedAt: time.Now(),
        Versions:    t.getSortedVersions(),
        Issues:      []CompatibilityIssue{},
    }
    
    // 收集所有兼容性问题
    for _, version := range report.Versions {
        issues := t.findCompatibilityIssues(version)
        report.Issues = append(report.Issues, issues...)
    }
    
    // 输出报告
    if t.config.OutputFormat == "json" {
        return t.outputJSON(report)
    } else if t.config.OutputFormat == "html" {
        return t.outputHTML(report)
    }
    
    return t.outputText(report)
}

8. 主要特性

1. 多版本支持: 支持测试多个 Kubernetes 版本之间的兼容性
2. API 生命周期验证: 验证 API 的 GA/Beta/Alpha 生命周期是否符合策略
3. 向前/向后兼容性: 同时检查向前和向后兼容性
4. 版本跳过检测: 检测是否跳过了必要的版本
5. 报告生成: 支持多种格式的兼容性报告

9. 关键设计模式

• Builder Pattern: 用于构建测试配置
• Strategy Pattern: 不同的兼容性检查策略
• Observer Pattern: 测试进度监控
• Factory Pattern: 创建不同版本的客户端

使用示例

# 测试指定版本范围的兼容性
go run main.go --min-version=1.30 --max-version=1.35

# 生成JSON格式报告
go run main.go --output=json --report-file=compat-report.json

# 跳过特定API的检查
go run main.go --skip-apis=networking.k8s.io/v1beta1

这个工具是 Kubernetes 质量保证的重要组成部分，确保版本升级不会破坏现有 API 的兼容性，对维护 Kubernetes 生态系统的稳定性至关重要。