CFE-682 : Replace deprecated functions of apimachinery/wait pkg

Author: bharath-b-rh

pkg/operator/finalizer.go

@@ -98,34 +98,36 @@ func (c *Controller) finalizeResources(o *imageregistryv1.Config) error {
 
 	retryTime := 3 * time.Second
 
-	err = wait.PollInfinite(retryTime, func() (stop bool, err error) {
-		_, err = c.listers.RegistryConfigs.Get(o.Name)
-		if err == nil {
-			return
-		}
+	err = wait.PollUntilContextCancel(context.Background(), retryTime, false,
+		func(context.Context) (stop bool, err error) {
+			_, err = c.listers.RegistryConfigs.Get(o.Name)
+			if err == nil {
+				return
+			}
 
-		if !kerrors.IsNotFound(err) {
-			for _, isRetryError := range errorFuncs {
-				if isRetryError(err) {
-					return false, nil
+			if !kerrors.IsNotFound(err) {
+				for _, isRetryError := range errorFuncs {
+					if isRetryError(err) {
+						return false, nil
+					}
 				}
-			}
 
-			// If the error sends the Retry-After header, we respect it as an explicit confirmation we should retry.
-			if delaySeconds, shouldRetry := kerrors.SuggestsClientDelay(err); shouldRetry {
-				delayTime := time.Duration(delaySeconds) * time.Second
-				if retryTime < delayTime {
-					time.Sleep(delayTime - retryTime)
+				// If the error sends the Retry-After header, we respect it as an explicit confirmation we should retry.
+				if delaySeconds, shouldRetry := kerrors.SuggestsClientDelay(err); shouldRetry {
+					delayTime := time.Duration(delaySeconds) * time.Second
+					if retryTime < delayTime {
+						time.Sleep(delayTime - retryTime)
+					}
+					return false, nil
 				}
-				return false, nil
-			}
 
-			err = fmt.Errorf("failed to get %s: %s", utilObjectInfo(o), err)
-			return
-		}
+				err = fmt.Errorf("failed to get %s: %s", utilObjectInfo(o), err)
+				return
+			}
 
-		return true, nil
-	})
+			return true, nil
+		},
+	)
 
 	if err != nil {
 		return fmt.Errorf("unable to wait for %s deletion: %s", utilObjectInfo(o), err)

pkg/resource/deployment_test.go

@@ -164,18 +164,20 @@ func testSecret(sData map[string][]byte) *corev1.Secret {
 }
 
 func waitForUpdatedSecret(ctx context.Context, kubeClient kubeclient.Interface, expectedData map[string][]byte) error {
-	err := wait.Poll(time.Second, time.Minute, func() (stop bool, err error) {
-		sec, err := kubeClient.CoreV1().Secrets(defaults.ImageRegistryOperatorNamespace).Get(ctx, defaults.ImageRegistryPrivateConfiguration, metav1.GetOptions{})
-		if err != nil {
-			// Keep waiting
+	err := wait.PollUntilContextTimeout(ctx, time.Second, time.Minute, false,
+		func(context.Context) (stop bool, err error) {
+			sec, err := kubeClient.CoreV1().Secrets(defaults.ImageRegistryOperatorNamespace).Get(ctx, defaults.ImageRegistryPrivateConfiguration, metav1.GetOptions{})
+			if err != nil {
+				// Keep waiting
+				return false, nil
+			}
+			if reflect.DeepEqual(sec.Data, expectedData) {
+				return true, nil
+			}
+			// Keep trying
 			return false, nil
-		}
-		if reflect.DeepEqual(sec.Data, expectedData) {
-			return true, nil
-		}
-		// Keep trying
-		return false, nil
-	})
+		},
+	)
 	return err
 }
 

pkg/resource/generator.go

@@ -298,16 +298,18 @@ func (g *Generator) Remove(cr *imageregistryv1.Config) error {
 
 	var derr error
 	var retriable bool
-	err = wait.PollImmediate(1*time.Second, 5*time.Minute, func() (stop bool, err error) {
-		if retriable, derr = driver.RemoveStorage(cr); derr != nil {
-			if retriable {
-				return false, nil
-			} else {
-				return true, derr
+	err = wait.PollUntilContextTimeout(context.Background(), 1*time.Second, 5*time.Minute, true,
+		func(context.Context) (stop bool, err error) {
+			if retriable, derr = driver.RemoveStorage(cr); derr != nil {
+				if retriable {
+					return false, nil
+				} else {
+					return true, derr
+				}
 			}
-		}
-		return true, nil
-	})
+			return true, nil
+		},
+	)
 	if err != nil {
 		return fmt.Errorf("unable to remove storage: %s, %s", err, derr)
 	}

test/e2e/aws_test.go

@@ -345,7 +345,7 @@ func TestAWSUnableToCreateBucketOnStartup(t *testing.T) {
 	}
 
 	// Create the image-registry-private-configuration-user secret using the invalid credentials
-	if _, err := framework.CreateOrUpdateSecret(defaults.ImageRegistryPrivateConfigurationUser, defaults.ImageRegistryOperatorNamespace, fakeAWSCredsData); err != nil {
+	if _, err := framework.CreateOrUpdateSecret(context.Background(), defaults.ImageRegistryPrivateConfigurationUser, defaults.ImageRegistryOperatorNamespace, fakeAWSCredsData); err != nil {
 		t.Fatalf("unable to create secret %q: %#v", fmt.Sprintf("%s/%s", defaults.ImageRegistryOperatorNamespace, defaults.ImageRegistryPrivateConfigurationUser), err)
 	}
 
@@ -404,13 +404,15 @@ func TestAWSUpdateCredentials(t *testing.T) {
 	framework.EnsureClusterOperatorStatusIsNormal(te)
 
 	// Create the image-registry-private-configuration-user secret using the invalid credentials
-	err = wait.PollImmediate(1*time.Second, framework.AsyncOperationTimeout, func() (stop bool, err error) {
-		if _, err := framework.CreateOrUpdateSecret(defaults.ImageRegistryPrivateConfigurationUser, defaults.ImageRegistryOperatorNamespace, fakeAWSCredsData); err != nil {
-			t.Logf("unable to create secret: %s", err)
-			return false, nil
-		}
-		return true, nil
-	})
+	err = wait.PollUntilContextTimeout(context.Background(), 1*time.Second, framework.AsyncOperationTimeout, true,
+		func(ctx context.Context) (stop bool, err error) {
+			if _, err := framework.CreateOrUpdateSecret(ctx, defaults.ImageRegistryPrivateConfigurationUser, defaults.ImageRegistryOperatorNamespace, fakeAWSCredsData); err != nil {
+				t.Logf("unable to create secret: %s", err)
+				return false, nil
+			}
+			return true, nil
+		},
+	)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -580,42 +582,44 @@ func TestAWSChangeS3Encryption(t *testing.T) {
 	}
 
 	found := false
-	err = wait.Poll(1*time.Second, framework.AsyncOperationTimeout, func() (stop bool, err error) {
-		// Check that the S3 bucket has the correct encryption configuration
-		getBucketEncryptionResult, err = svc.GetBucketEncryption(&s3.GetBucketEncryptionInput{
-			Bucket: aws.String(cr.Spec.Storage.S3.Bucket),
-		})
-		if aerr, ok := err.(awserr.Error); ok {
-			t.Errorf("%#v, %#v", aerr.Code(), aerr.Error())
-		}
-		if err != nil {
-			return true, err
-		}
+	err = wait.PollUntilContextTimeout(context.Background(), 1*time.Second, framework.AsyncOperationTimeout, false,
+		func(context.Context) (stop bool, err error) {
+			// Check that the S3 bucket has the correct encryption configuration
+			getBucketEncryptionResult, err = svc.GetBucketEncryption(&s3.GetBucketEncryptionInput{
+				Bucket: aws.String(cr.Spec.Storage.S3.Bucket),
+			})
+			if aerr, ok := err.(awserr.Error); ok {
+				t.Errorf("%#v, %#v", aerr.Code(), aerr.Error())
+			}
+			if err != nil {
+				return true, err
+			}
 
-		wantedBucketEncryption = &s3.ServerSideEncryptionConfiguration{
-			Rules: []*s3.ServerSideEncryptionRule{
-				{
-					ApplyServerSideEncryptionByDefault: &s3.ServerSideEncryptionByDefault{
-						SSEAlgorithm:   aws.String(s3.ServerSideEncryptionAwsKms),
-						KMSMasterKeyID: aws.String("testKey"),
+			wantedBucketEncryption = &s3.ServerSideEncryptionConfiguration{
+				Rules: []*s3.ServerSideEncryptionRule{
+					{
+						ApplyServerSideEncryptionByDefault: &s3.ServerSideEncryptionByDefault{
+							SSEAlgorithm:   aws.String(s3.ServerSideEncryptionAwsKms),
+							KMSMasterKeyID: aws.String("testKey"),
+						},
+						BucketKeyEnabled: aws.Bool(false),
 					},
-					BucketKeyEnabled: aws.Bool(false),
 				},
-			},
-		}
+			}
 
-		for _, wantedEncryptionRule := range wantedBucketEncryption.Rules {
-			for _, gotRule := range getBucketEncryptionResult.ServerSideEncryptionConfiguration.Rules {
-				if reflect.DeepEqual(wantedEncryptionRule, gotRule) {
-					found = true
-					break
-				} else {
-					return false, nil
+			for _, wantedEncryptionRule := range wantedBucketEncryption.Rules {
+				for _, gotRule := range getBucketEncryptionResult.ServerSideEncryptionConfiguration.Rules {
+					if reflect.DeepEqual(wantedEncryptionRule, gotRule) {
+						found = true
+						break
+					} else {
+						return false, nil
+					}
 				}
 			}
-		}
-		return true, nil
-	})
+			return true, nil
+		},
+	)
 	if err != nil {
 		t.Errorf("an error occurred checking for bucket encryption: %#v", err)
 	}
@@ -732,21 +736,23 @@ func TestAWSFinalizerDeleteS3Bucket(t *testing.T) {
 	}
 	s3Client := s3.New(sess)
 	exists := true
-	err = wait.Poll(5*time.Second, framework.AsyncOperationTimeout, func() (stop bool, err error) {
-		_, err = s3Client.HeadBucket(&s3.HeadBucketInput{
-			Bucket: aws.String(cr.Status.Storage.S3.Bucket),
-		})
-
-		if aerr, ok := err.(awserr.Error); ok {
-			switch aerr.Code() {
-			case s3.ErrCodeNoSuchBucket, "Forbidden", "NotFound":
-				exists = false
-				return true, nil
+	err = wait.PollUntilContextTimeout(context.Background(), 5*time.Second, framework.AsyncOperationTimeout, false,
+		func(context.Context) (stop bool, err error) {
+			_, err = s3Client.HeadBucket(&s3.HeadBucketInput{
+				Bucket: aws.String(cr.Status.Storage.S3.Bucket),
+			})
+
+			if aerr, ok := err.(awserr.Error); ok {
+				switch aerr.Code() {
+				case s3.ErrCodeNoSuchBucket, "Forbidden", "NotFound":
+					exists = false
+					return true, nil
+				}
 			}
-		}
 
-		return false, err
-	})
+			return false, err
+		},
+	)
 	if err != nil {
 		t.Errorf("an error occurred checking for s3 bucket existence: %#v", err)
 	}

test/e2e/bootstrap_test.go

@@ -1,6 +1,7 @@
 package e2e
 
 import (
+	"context"
 	"strings"
 	"testing"
 
@@ -11,7 +12,7 @@ func TestBootstrapFailToUpdateSpec(t *testing.T) {
 	te := framework.SetupAvailableImageRegistry(t, nil)
 	defer framework.TeardownImageRegistry(te)
 
-	logs, err := framework.GetOperatorLogs(te.Client())
+	logs, err := framework.GetOperatorLogs(context.Background(), te.Client())
 	if err != nil {
 		t.Fatalf("error reading operator logs: %s", err)
 	}

test/e2e/configuration_test.go

@@ -452,7 +452,7 @@ func TestSecureRouteConfiguration(t *testing.T) {
 		"tls.key": string(key),
 	}
 
-	if _, err := framework.CreateOrUpdateSecret(tlsSecretName, defaults.ImageRegistryOperatorNamespace, tlsSecretData); err != nil {
+	if _, err := framework.CreateOrUpdateSecret(context.Background(), tlsSecretName, defaults.ImageRegistryOperatorNamespace, tlsSecretData); err != nil {
 		t.Fatalf("unable to create secret: %s", err)
 	}
 
@@ -476,25 +476,27 @@ func TestSecureRouteConfiguration(t *testing.T) {
 	framework.EnsureClusterOperatorStatusIsNormal(te)
 	framework.EnsureExternalRegistryHostnamesAreSet(te, []string{hostname})
 
-	err = wait.Poll(5*time.Second, 1*time.Minute, func() (done bool, err error) {
-		route, err := te.Client().Routes(defaults.ImageRegistryOperatorNamespace).Get(
-			context.Background(), routeName, metav1.GetOptions{},
-		)
-		if err != nil {
-			t.Logf("unable to get route: %s", err)
-			return false, nil
-		}
-		if route.Spec.TLS == nil {
-			t.Fatal("route.Spec.TLS is nil, want a configuration")
-		}
-		if route.Spec.TLS.Certificate != string(cert) {
-			t.Errorf("route tls certificate: got %q, want %q", route.Spec.TLS.Certificate, string(cert))
-		}
-		if route.Spec.TLS.Key != string(key) {
-			t.Errorf("route tls key: got %q, want %q", route.Spec.TLS.Key, string(key))
-		}
-		return true, nil
-	})
+	err = wait.PollUntilContextTimeout(context.Background(), 5*time.Second, 1*time.Minute, false,
+		func(ctx context.Context) (done bool, err error) {
+			route, err := te.Client().Routes(defaults.ImageRegistryOperatorNamespace).Get(
+				ctx, routeName, metav1.GetOptions{},
+			)
+			if err != nil {
+				t.Logf("unable to get route: %s", err)
+				return false, nil
+			}
+			if route.Spec.TLS == nil {
+				t.Fatal("route.Spec.TLS is nil, want a configuration")
+			}
+			if route.Spec.TLS.Certificate != string(cert) {
+				t.Errorf("route tls certificate: got %q, want %q", route.Spec.TLS.Certificate, string(cert))
+			}
+			if route.Spec.TLS.Key != string(key) {
+				t.Errorf("route tls key: got %q, want %q", route.Spec.TLS.Key, string(key))
+			}
+			return true, nil
+		},
+	)
 	if err != nil {
 		t.Fatalf("failed to observe the route: %s", err)
 	}
@@ -524,26 +526,28 @@ func TestVersionReporting(t *testing.T) {
 
 	framework.WaitUntilDeploymentIsRolledOut(te, framework.OperatorDeploymentNamespace, framework.OperatorDeploymentName)
 
-	err := wait.Poll(5*time.Second, 1*time.Minute, func() (bool, error) {
-		clusterOperatorStatus, err := te.Client().ClusterOperators().Get(
-			context.Background(), defaults.ImageRegistryClusterOperatorResourceName, metav1.GetOptions{},
-		)
-		if err != nil {
-			t.Logf("Could not retrieve cluster operator status: %v", err)
-			return false, nil
-		}
-		if len(clusterOperatorStatus.Status.Versions) == 0 {
-			// We should always have *some* version information in the clusteroperator once we are available,
-			// so we do not retry in this scenario.
-			t.Fatalf("Cluster operator status has no version information: %v", clusterOperatorStatus)
-			return true, err
-		}
-		if clusterOperatorStatus.Status.Versions[0].Name != "operator" || clusterOperatorStatus.Status.Versions[0].Version != "test-v2" {
-			t.Logf("waiting for new version to be reported, saw: %v", clusterOperatorStatus.Status.Versions[0])
-			return false, nil
-		}
-		return true, nil
-	})
+	err := wait.PollUntilContextTimeout(context.Background(), 5*time.Second, 1*time.Minute, false,
+		func(ctx context.Context) (bool, error) {
+			clusterOperatorStatus, err := te.Client().ClusterOperators().Get(
+				ctx, defaults.ImageRegistryClusterOperatorResourceName, metav1.GetOptions{},
+			)
+			if err != nil {
+				t.Logf("Could not retrieve cluster operator status: %v", err)
+				return false, nil
+			}
+			if len(clusterOperatorStatus.Status.Versions) == 0 {
+				// We should always have *some* version information in the clusteroperator once we are available,
+				// so we do not retry in this scenario.
+				t.Fatalf("Cluster operator status has no version information: %v", clusterOperatorStatus)
+				return true, err
+			}
+			if clusterOperatorStatus.Status.Versions[0].Name != "operator" || clusterOperatorStatus.Status.Versions[0].Version != "test-v2" {
+				t.Logf("waiting for new version to be reported, saw: %v", clusterOperatorStatus.Status.Versions[0])
+				return false, nil
+			}
+			return true, nil
+		},
+	)
 	if err != nil {
 		t.Fatalf("failed to observe updated version reported in clusteroperator status: %v", err)
 	}

test/e2e/emptydir_test.go

@@ -41,7 +41,7 @@ func TestBasicEmptyDir(t *testing.T) {
 		t.Errorf("error: the deployment doesn't have available replicas")
 	}
 
-	logs, err := framework.GetOperatorLogs(te.Client())
+	logs, err := framework.GetOperatorLogs(context.Background(), te.Client())
 	if err != nil {
 		t.Fatal(err)
 	}