重试控制策略

import "k8s.io/client-go/util/retry"

// 创建一个自定义的退避策略
waitBackoff := wait.Backoff{
    Duration: 2 * time.Second, // 初始退避间隔
    Factor:   2,               // 退避系数
    Jitter:   0.1,             // 随机化因子
    Steps:    10,              // 最大重试次数
}

package main

import (
    "fmt"
    "math/rand"
    "time"

    "k8s.io/apimachinery/pkg/util/wait"
    "k8s.io/client-go/util/retry"
    "k8s.io/klog/v2"
)

var numberOfRetries = 0

func main() {
    // 创建一个自定义的退避策略

    waitBackoff := wait.Backoff{
        Duration: 2 * time.Second, // 初始退避间隔
        Factor:   2,               // 退避系数
        Jitter:   0.1,             // 随机化因子
        Steps:    10,              // 最大重试次数
    }

    // 自定义的退避策略函数
    backoffFunc := func() error {
        klog.Infof("Performing operation...")
        err := performOperation()
        if err != nil {
            klog.Warningf("Operation failed: %v", err)
            return err
        }
        klog.Infof("Operation succeeded.")
        return nil
    }

    // 使用自定义的退避策略执行操作
    err := retry.OnError(waitBackoff, shouldRetry, backoffFunc)
    if err != nil {
        klog.Errorf("Failed to perform operation: %v", err)
    } else {
        klog.Infof("Operation completed successfully.")
    }
}

// 执行操作的函数
func performOperation() error {
    numberOfRetries++
    klog.Infof(fmt.Sprintf("Start %d retry", numberOfRetries))
    // 模拟操作失败的情况
    if rand.Intn(10) < 9 {
        return fmt.Errorf("Operation failed")
    }
    return nil
}

// 判断是否应该重试的函数
func shouldRetry(err error) bool {
    // 这里可以根据具体的错误类型进行判断
    return true
}

retryErr := retry.RetryOnConflict(
    retry.DefaultRetry,
    func() error {
        user, err := authClient.Users().Get(context.TODO(), req.Username, metav1.GetOptions{})
        if err != nil {
            return err
        }
        newUser := user.DeepCopy()
        newUser.Status.AuditLog.CreateTime = currentTimeStr
        _, err = authClient.Users().UpdateStatus(context.TODO(), newUser, metav1.UpdateOptions{})
        return err
    },
)

// // DefaultRetry is the recommended retry for a conflict where multiple clients
// // are making changes to the same resource.
// var DefaultRetry = wait.Backoff{
//  Steps:    5,
//  Duration: 10 * time.Millisecond,
//  Factor:   1.0,
//  Jitter:   0.1,
// }