}
	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)

				defaultOptions := []retry.Option{retry.Delay(100 * time.Millisecond), retry.Timeout(200 * time.Second)}
				httpOpts := echo.CallOptions{
					Address: hostname,
					Port: echo.Port{
						Name:        "http",
						ServicePort: 80,
						Protocol:    protocol.HTTP,
					},
					HTTP:  http,
					Count: 1,
					Retry: echo.Retry{
						Options: append(defaultOptions, retry.Timeout(framework.TelemetryRetryTimeout)),

			}

			// perform one retry to handle race condition where ztunnel cert is refreshed before Istiod certificates are reloaded
			retry.UntilSuccess(func() error {
				newWorkloadCert := waitForWorkloadCertUpdate(t, ztunnelPod, sa, istioCtl, originalWorkloadSecret)
				return verifyWorkloadCert(t, newWorkloadCert, newX509)
			}, retry.MaxAttempts(2), retry.Timeout(5*time.Minute))
		})
}

        buildFile << """
            plugins {
                id "java"
                id "org.gradle.test-retry" version "${TestedVersions.testRetryPlugin}"
            }

            ${mavenCentralRepository()}
        """
    }

    @Issue('https://plugins.gradle.org/plugin/org.gradle.test-retry')
    def 'test retry plugin'() {
        given:
        buildFile << """
            dependencies {

					authenticationconfigmetrics.RecordAuthenticationConfigAutomaticReloadFailure(apiServerID)
					// we do not update the tracker here because this error could eventually resolve as we keep retrying
					return
				}

				authConfigData := string(authConfigBytes)

				if authConfigData == trackedAuthenticationConfigData {
					return
				}

	BVS  loop        // branch back if interrupted
	BGT  retry       // signing unsuccessful, but retry with new CSPRN
	BLT  error       // condition code of 1 indicates a failure

success:
	MOVD $0, errn+16(FP) // return 0 - sign/verify was successful
	RET

error:
	MOVD $1, errn+16(FP) // return 1 - sign/verify failed
	RET

retry:

		fetch(unpatchedWebhookConfig.Name),
		webhookConfigAfterCAUpdate,
		retry.Message("webhook should change after cert change"),
		LongRetry,
	)
}

// LongRetry is used when comparing webhook values. Apparently the values are so large that with -race
// on the comparison can take a few seconds, meaning we never retry with the default settings.
var LongRetry = retry.Timeout(time.Second * 20)

func TestLoadCaCertPem(t *testing.T) {

				_, err = util.QueryPrometheus(t, cluster, grpcDestinationQuery, promInst)
				if err != nil {
					util.PromDiff(t, promInst, cluster, grpcDestinationQuery)
					return err
				}
				return nil
			}, retry.Delay(1*time.Second), retry.Timeout(300*time.Second))
			// check tag removed
			if strings.Contains(httpMetricVal, removedTag) {
				t.Errorf("failed to remove tag: %v", removedTag)
			}

		c.queue.Add(driverName)
	}
}

// monitorPlugin calls the plugin to retrieve resource information and caches
// all responses that it gets for processing in the sync method. It keeps
// retrying until an error or EOF response indicates that no further data is
// going to be sent, then watch resources of the plugin stops until it
// re-registers.