portion of the URL with this value. type: string type: object retries: description: Retry policy for HTTP requests. properties: attempts: description: Number of retries to be allowed for a given request. format: int32 type: integer perTryTimeout: description: Timeout per attempt for a given request, including the initial call and any retries. type: string retryOn: description: Specifies the conditions under which retry takes place. type: string retryRemoteLocalitie: description: Flag to specify whether...

                    "Cluster": "outbound|2001||s1http.none"
                  },
                  "HostRewriteSpecifier": null,
                  "timeout": 0,
                  "retry_policy": {
                    "retry_on": "connect-failure,refused-stream,unavailable,cancelled,resource-exhausted,retriable-status-codes",
                    "num_retries": {
                      "value": 2
                    },

	}

	<-stopCh
}

// runOnce verifies the state of the ClusterIP allocations and returns an error if an unrecoverable problem occurs.
func (r *RepairIPAddress) runOnce() error {
	return retry.RetryOnConflict(retry.DefaultBackoff, r.doRunOnce)
}

// doRunOnce verifies the state of the ClusterIP allocations and returns an error if an unrecoverable problem occurs.
func (r *RepairIPAddress) doRunOnce() error {

                    "route": {
                      "cluster": "outbound|9080||productpage.default.svc.cluster.local",
                      "timeout": "0s",
                      "retry_policy": {
                        "retry_on": "connect-failure,refused-stream,unavailable,cancelled,retriable-status-codes",
                        "num_retries": 2,
                        "retry_host_predicate": [
                          {

}

// WaitForClusterAvailable returns true if all endpoints in the cluster are available after retry attempts, an error is returned otherwise
func (c *Client) WaitForClusterAvailable(retries int, retryInterval time.Duration) (bool, error) {
	for i := 0; i < retries; i++ {
		if i > 0 {
			klog.V(1).Infof("[etcd] Waiting %v until next retry\n", retryInterval)
			time.Sleep(retryInterval)
		}

	}
	return nil
}

func sendTraffic(ctx framework.TestContext, checker echo.Checker, options ...retry.Option) {
	ctx.Helper()
	if len(GetClientInstances()) == 0 {
		ctx.Fatal("there is no client")
	}
	cltInstance := GetClientInstances()[0]

	defaultOptions := []retry.Option{retry.Delay(100 * time.Millisecond), retry.Timeout(200 * time.Second)}
	httpOpts := echo.CallOptions{
		To: GetTarget(),
		Port: echo.Port{

		}
		return nil
	}, retry.Timeout(time.Second), retry.BackoffDelay(time.Millisecond))
	if err != nil {
		t.t.Fatal(err)
	}
	t.Empty()
}

// WaitCompare waits for an event to happen and ensures it meets a custom comparison function
func (t *Tracker[T]) WaitCompare(f func(T) bool) {
	t.t.Helper()
	var err error
	retry.UntilSuccessOrFail(t.t, func() error {
		t.mu.Lock()

	}
	defer svmc.queue.Done(key)

	err := svmc.sync(ctx, key)
	if err == nil {
		svmc.queue.Forget(key)
		return true
	}

	klog.FromContext(ctx).V(2).Info("Error syncing SVM resource, retrying", "svm", key, "err", err)
	svmc.queue.AddRateLimited(key)

	return true
}

func (svmc *SVMController) sync(ctx context.Context, key string) error {
	logger := klog.FromContext(ctx)

	if err != nil {
		return err
	}
	resp, err := hr.httpDoer.Do(req)
	discardHTTPRespBody(resp)

	if isHTTPResponseError(err) {
		klog.V(1).ErrorS(err, "HTTPS request to lifecycle hook got HTTP response, retrying with HTTP.", "pod", klog.KObj(pod), "host", req.URL.Host)

		req := req.Clone(context.Background())
		req.URL.Scheme = "http"
		req.Header.Del("Authorization")
		resp, httpErr := hr.httpDoer.Do(req)

		}
		return nil
	}, retry.Timeout(time.Second*5), retry.Converge(5))
	retry.UntilOrFail(t, func() bool {
		return store.Get(r.GroupVersionKind(), configMeta.Name, configMeta.Namespace) == nil
	}, retry.Message("expected no items returned for unknown CRD"), retry.Timeout(time.Second*5), retry.Converge(5))
}