// 这是一个极度简化的控制器逻辑伪代码，用于说明原理
for {
    // 1. 观察：获取自定义资源的期望状态
    desiredCluster := client.Get(“my-redis-cluster”, “production”)

    // 2. 分析：获取集群当前的实际状态
    currentPods := k8sClient.ListPods(“app=redis, cluster=my-redis-cluster”)
    currentConfigMap := k8sClient.GetConfigMap(“redis-config-my-redis-cluster”)
    // ... 检查其他资源（Service, StatefulSet, PVC等）

    // 3. 比较分析：计算当前状态与期望状态的差异
    diff := reconcile(desiredCluster, currentPods, currentConfigMap)

    // 4. 执行：发出指令使实际状态向期望状态收敛
    if diff.needsScaleUp {
        k8sClient.PatchStatefulSetReplicas(“redis-statefulset”, desiredCluster.Spec.Size)
    }
    if diff.needsConfigUpdate {
        k8sClient.UpdateConfigMap(“redis-config-my-redis-cluster”, diff.newConfig)
    }
    if diff.needsBackup {
        runBackupJob(desiredCluster)
    }

    // 5. 等待或监听新的事件
    waitForChange(desiredCluster)
}

package controllers

import (
    "context"
    "fmt"
    "github.com/go-logr/logr"
    "k8s.io/apimachinery/pkg/api/errors"
    "k8s.io/apimachinery/pkg/runtime"
    ctrl "sigs.k8s.io/controller-runtime"
    "sigs.k8s.io/controller-runtime/pkg/client"
    batchv1 "k8s.io/api/batch/v1"
    corev1 "k8s.io/api/core/v1"
    metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
    examplecomv1 "github.com/your-org/api/v1"
)

// ScheduledJobReconciler 调和器
type ScheduledJobReconciler struct {
    client.Client
    Log    logr.Logger
    Scheme *runtime.Scheme
}

// +kubebuilder:rbac:groups=example.com,resources=scheduledjobs,verbs=get;list;watch;create;update;patch;delete
// +kubebuilder:rbac:groups=example.com,resources=scheduledjobs/status,verbs=get;update;patch
// +kubebuilder:rbac:groups=batch,resources=jobs,verbs=get;list;watch;create;update;patch;delete

func (r *ScheduledJobReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) {
    log := r.Log.WithValues("scheduledjob", req.NamespacedName)

    // 1. 获取ScheduledJob CR实例
    var sj examplecomv1.ScheduledJob
    if err := r.Get(ctx, req.NamespacedName, &sj); err != nil {
        if errors.IsNotFound(err) {
            // CR被删除，执行清理逻辑
            return ctrl.Result{}, nil
        }
        return ctrl.Result{}, err
    }

    // 2. 根据CRON表达式计算下一次运行时间（此处为简化，假设每次调和都运行）
    // 实际生产环境会使用更复杂的调度库（如robfig/cron）并记录上次运行时间。
    // 这里我们简单地为每个ScheduledJob创建一个对应的K8s Job。

    jobName := fmt.Sprintf("%s-job-%d", sj.Name, time.Now().Unix())

    // 3. 检查Job是否已存在
    var existingJob batchv1.Job
    err := r.Get(ctx, client.ObjectKey{Namespace: sj.Namespace, Name: jobName}, &existingJob)
    if err != nil && errors.IsNotFound(err) {
        // 4. Job不存在，根据模板创建
        log.Info("Creating a new Job", "Job.Namespace", sj.Namespace, "Job.Name", jobName)
        job := &batchv1.Job{
            ObjectMeta: metav1.ObjectMeta{
                Name:      jobName,
                Namespace: sj.Namespace,
                OwnerReferences: []metav1.OwnerReference{ // 设置属主引用，实现级联删除
                    *metav1.NewControllerRef(&sj, examplecomv1.GroupVersion.WithKind("ScheduledJob")),
                },
            },
            Spec: *sj.Spec.JobTemplate.Spec.DeepCopy(), // 深拷贝模板中的Job Spec
        }
        if err := r.Create(ctx, job); err != nil {
            return ctrl.Result{}, err
        }
    } else if err != nil {
        return ctrl.Result{}, err
    }

    // 5. 更新CR状态（可选）
    // sj.Status.LastRunTime = &metav1.Time{Time: time.Now()}
    // if err := r.Status().Update(ctx, &sj); err != nil { ... }

    // 6. 设定下次调和时间（模拟CRON调度）
    // 这里返回一个Result，要求10分钟后重新调和此对象
    return ctrl.Result{RequeueAfter: 10 * time.Minute}, nil
}

// SetupWithManager 设置控制器管理器
func (r *ScheduledJobReconciler) SetupWithManager(mgr ctrl.Manager) error {
    return ctrl.NewControllerManagedBy(mgr).
        For(&examplecomv1.ScheduledJob{}).
        Owns(&batchv1.Job{}). // 监听由本控制器创建的Job的变化
        Complete(r)
}