Fix compilation errors (mostly context.TODOs)

pkg/apps/appsutil/util.go

@@ -9,8 +9,8 @@ import (
 	"strings"
 	"time"
 
-	"k8s.io/api/core/v1"
 	corev1 "k8s.io/api/core/v1"
+	v1 "k8s.io/api/core/v1"
 	"k8s.io/apimachinery/pkg/api/meta"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/fields"
@@ -44,11 +44,11 @@ func WaitForRunningDeployerPod(podClient corev1client.PodsGetter, rc *corev1.Rep
 	lw := &cache.ListWatch{
 		ListFunc: func(options metav1.ListOptions) (runtime.Object, error) {
 			options.FieldSelector = fieldSelector
-			return podClient.Pods(rc.Namespace).List(options)
+			return podClient.Pods(rc.Namespace).List(context.TODO(), options)
 		},
 		WatchFunc: func(options metav1.ListOptions) (watch.Interface, error) {
 			options.FieldSelector = fieldSelector
-			return podClient.Pods(rc.Namespace).Watch(options)
+			return podClient.Pods(rc.Namespace).Watch(context.TODO(), options)
 		},
 	}
 

pkg/assets/create/creater.go

@@ -171,7 +171,7 @@ func create(ctx context.Context, manifests map[string]*unstructured.Unstructured
 		}
 		resourceString := mappings.Resource.Resource + "." + mappings.Resource.Version + "." + mappings.Resource.Group + "/" + manifests[path].GetName() + " -n " + manifests[path].GetNamespace()
 
-		incluster, err := resource.Create(manifests[path], metav1.CreateOptions{})
+		incluster, err := resource.Create(ctx, manifests[path], metav1.CreateOptions{})
 
 		if err == nil && options.Verbose {
 			fmt.Fprintf(options.StdErr, "Created %q %s\n", path, resourceString)
@@ -183,7 +183,7 @@ func create(ctx context.Context, manifests map[string]*unstructured.Unstructured
 			if options.Verbose {
 				fmt.Fprintf(options.StdErr, "Skipped %q %s as it already exists\n", path, resourceString)
 			}
-			incluster, err = resource.Get(manifests[path].GetName(), metav1.GetOptions{})
+			incluster, err = resource.Get(ctx, manifests[path].GetName(), metav1.GetOptions{})
 			if err != nil {
 				if options.Verbose {
 					fmt.Fprintf(options.StdErr, "Failed to get already existing %q %s: %v\n", path, resourceString, err)
@@ -205,7 +205,7 @@ func create(ctx context.Context, manifests map[string]*unstructured.Unstructured
 			_, found := incluster.Object["status"]
 			if !found {
 				incluster.Object["status"] = manifests[path].Object["status"]
-				incluster, err = resource.UpdateStatus(incluster, metav1.UpdateOptions{})
+				incluster, err = resource.UpdateStatus(ctx, incluster, metav1.UpdateOptions{})
 				if err != nil && !kerrors.IsNotFound(err) {
 					if options.Verbose {
 						fmt.Fprintf(options.StdErr, "Failed to update status for the %q %s: %v\n", path, resourceString, err)

pkg/authentication/bootstrapauthenticator/bootstrap.go

@@ -16,7 +16,7 @@ import (
 	"k8s.io/apimachinery/pkg/util/sets"
 	"k8s.io/apiserver/pkg/authentication/authenticator"
 	"k8s.io/apiserver/pkg/authentication/user"
-	"k8s.io/client-go/kubernetes/typed/core/v1"
+	v1 "k8s.io/client-go/kubernetes/typed/core/v1"
 )
 
 const (
@@ -145,7 +145,7 @@ func (b *bootstrapUserDataGetter) IsEnabled() (bool, error) {
 }
 
 func (b *bootstrapUserDataGetter) getBootstrapUserSecret() (*corev1.Secret, error) {
-	secret, err := b.secrets.Get(bootstrapUserBasicAuth, metav1.GetOptions{})
+	secret, err := b.secrets.Get(context.TODO(), bootstrapUserBasicAuth, metav1.GetOptions{})
 	if errors.IsNotFound(err) {
 		klog.V(4).Infof("%s secret does not exist", bootstrapUserBasicAuth)
 		return nil, nil
@@ -157,7 +157,7 @@ func (b *bootstrapUserDataGetter) getBootstrapUserSecret() (*corev1.Secret, erro
 		klog.V(4).Infof("%s secret is being deleted", bootstrapUserBasicAuth)
 		return nil, nil
 	}
-	namespace, err := b.namespaces.Get(metav1.NamespaceSystem, metav1.GetOptions{})
+	namespace, err := b.namespaces.Get(context.TODO(), metav1.NamespaceSystem, metav1.GetOptions{})
 	if err != nil {
 		return nil, err
 	}

pkg/authorization/authorizationutil/util.go

@@ -1,10 +1,12 @@
 package authorizationutil
 
 import (
+	"context"
 	"errors"
 
 	authorizationv1 "k8s.io/api/authorization/v1"
 	kerrors "k8s.io/apimachinery/pkg/api/errors"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime/schema"
 	"k8s.io/apiserver/pkg/authentication/user"
 	authorizationclient "k8s.io/client-go/kubernetes/typed/authorization/v1"
@@ -36,7 +38,7 @@ func Authorize(sarClient authorizationclient.SubjectAccessReviewInterface, user
 		},
 	})
 
-	resp, err := sarClient.Create(sar)
+	resp, err := sarClient.Create(context.TODO(), sar, metav1.CreateOptions{})
 	if err == nil && resp != nil && resp.Status.Allowed {
 		return nil
 	}

pkg/build/envresolve/env.go

@@ -1,6 +1,7 @@
 package envresolve
 
 import (
+	"context"
 	"fmt"
 
 	corev1 "k8s.io/api/core/v1"
@@ -28,7 +29,7 @@ func getSecretRefValue(client kubernetes.Interface, namespace string, store *Res
 	secret, ok := store.SecretStore[secretSelector.Name]
 	if !ok {
 		var err error
-		secret, err = client.CoreV1().Secrets(namespace).Get(secretSelector.Name, metav1.GetOptions{})
+		secret, err = client.CoreV1().Secrets(namespace).Get(context.TODO(), secretSelector.Name, metav1.GetOptions{})
 		if err != nil {
 			return "", err
 		}
@@ -46,7 +47,7 @@ func getConfigMapRefValue(client kubernetes.Interface, namespace string, store *
 	configMap, ok := store.ConfigMapStore[configMapSelector.Name]
 	if !ok {
 		var err error
-		configMap, err = client.CoreV1().ConfigMaps(namespace).Get(configMapSelector.Name, metav1.GetOptions{})
+		configMap, err = client.CoreV1().ConfigMaps(namespace).Get(context.TODO(), configMapSelector.Name, metav1.GetOptions{})
 		if err != nil {
 			return "", err
 		}

pkg/controller/factory/factory_test.go

@@ -196,7 +196,7 @@ func TestControllerWithInformer(t *testing.T) {
 	go controller.Run(ctx, 1)
 	time.Sleep(1 * time.Second) // Give controller time to start
 
-	if _, err := kubeClient.CoreV1().Secrets("test").Create(makeFakeSecret()); err != nil {
+	if _, err := kubeClient.CoreV1().Secrets("test").Create(ctx, makeFakeSecret(), meta.CreateOptions{}); err != nil {
 		t.Fatalf("failed to create fake secret: %v", err)
 	}
 
@@ -240,7 +240,7 @@ func TestControllerWithQueueFunction(t *testing.T) {
 	go controller.Run(ctx, 1)
 	time.Sleep(1 * time.Second) // Give controller time to start
 
-	if _, err := kubeClient.CoreV1().Secrets("test").Create(makeFakeSecret()); err != nil {
+	if _, err := kubeClient.CoreV1().Secrets("test").Create(ctx, makeFakeSecret(), meta.CreateOptions{}); err != nil {
 		t.Fatalf("failed to create fake secret: %v", err)
 	}
 

pkg/oauth/oauthserviceaccountclient/oauthclientregistry.go

@@ -1,6 +1,7 @@
 package oauthserviceaccountclient
 
 import (
+	"context"
 	"fmt"
 	"net"
 	"net/url"
@@ -234,7 +235,7 @@ func (a *saOAuthClientAdapter) Get(name string, options metav1.GetOptions) (*oau
 		return a.delegate.Get(name, options)
 	}
 
-	sa, err := a.saClient.ServiceAccounts(saNamespace).Get(saName, metav1.GetOptions{})
+	sa, err := a.saClient.ServiceAccounts(saNamespace).Get(context.TODO(), saName, metav1.GetOptions{})
 	if err != nil {
 		return nil, err
 	}
@@ -393,13 +394,13 @@ func (a *saOAuthClientAdapter) redirectURIsFromRoutes(namespace string, osRouteN
 	routeErrors := []error{}
 	routeInterface := a.routeClient.Routes(namespace)
 	if osRouteNames.Len() > 1 {
-		if r, err := routeInterface.List(metav1.ListOptions{}); err == nil {
+		if r, err := routeInterface.List(context.TODO(), metav1.ListOptions{}); err == nil {
 			routes = r.Items
 		} else {
 			routeErrors = append(routeErrors, err)
 		}
 	} else {
-		if r, err := routeInterface.Get(osRouteNames.List()[0], metav1.GetOptions{}); err == nil {
+		if r, err := routeInterface.Get(context.TODO(), osRouteNames.List()[0], metav1.GetOptions{}); err == nil {
 			routes = append(routes, *r)
 		} else {
 			routeErrors = append(routeErrors, err)
@@ -466,7 +467,7 @@ func getScopeRestrictionsFor(namespace, name string) []oauthv1.ScopeRestriction
 
 // getServiceAccountTokens returns all ServiceAccountToken secrets for the given ServiceAccount
 func (a *saOAuthClientAdapter) getServiceAccountTokens(sa *corev1.ServiceAccount) ([]string, error) {
-	allSecrets, err := a.secretClient.Secrets(sa.Namespace).List(metav1.ListOptions{})
+	allSecrets, err := a.secretClient.Secrets(sa.Namespace).List(context.TODO(), metav1.ListOptions{})
 	if err != nil {
 		return nil, err
 	}

pkg/operator/apiserver/controller/apiservice/apigroup.go

@@ -1,6 +1,7 @@
 package apiservice
 
 import (
+	"context"
 	"fmt"
 	"net/http"
 
@@ -67,7 +68,7 @@ func checkDiscoveryForByAPIServices(recorder events.Recorder, restclient rest.In
 		url := "/apis/" + apiService.Spec.Group + "/" + apiService.Spec.Version
 
 		statusCode := 0
-		result := restclient.Get().AbsPath(url).Do().StatusCode(&statusCode)
+		result := restclient.Get().AbsPath(url).Do(context.TODO()).StatusCode(&statusCode)
 		if statusCode != http.StatusOK {
 			groupVersionString := fmt.Sprintf("%s.%s", apiService.Spec.Group, apiService.Spec.Version)
 			recorder.Warningf("OpenShiftAPICheckFailed", fmt.Sprintf("%q failed with HTTP status code %d (%v)", groupVersionString, statusCode, result.Error()))

pkg/operator/apiserver/controller/apiservice/apiservice_controller.go

@@ -7,6 +7,7 @@ import (
 	"strings"
 	"time"
 
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/util/errors"
 	kubeinformers "k8s.io/client-go/informers"
 	"k8s.io/client-go/kubernetes"
@@ -79,7 +80,7 @@ func (c *APIServiceController) sync(ctx context.Context, syncCtx factory.SyncCon
 			return errors.NewAggregate(errs)
 		}
 		for _, apiService := range apiServices {
-			if err := c.apiregistrationv1Client.APIServices().Delete(apiService.Name, nil); err != nil {
+			if err := c.apiregistrationv1Client.APIServices().Delete(ctx, apiService.Name, metav1.DeleteOptions{}); err != nil {
 				errs = append(errs, err)
 			}
 		}

pkg/operator/apiserver/controller/nsfinalizer/finalizer_controller.go

@@ -57,7 +57,7 @@ func NewFinalizerController(
 }
 
 func (c finalizerController) sync(ctx context.Context, syncCtx factory.SyncContext) error {
-	ns, err := c.namespaceGetter.Namespaces().Get(c.namespaceName, metav1.GetOptions{})
+	ns, err := c.namespaceGetter.Namespaces().Get(ctx, c.namespaceName, metav1.GetOptions{})
 	if apierrors.IsNotFound(err) {
 		return nil
 	}
@@ -104,6 +104,6 @@ func (c finalizerController) sync(ctx context.Context, syncCtx factory.SyncConte
 	ns.Spec.Finalizers = newFinalizers
 
 	syncCtx.Recorder().Event("NamespaceFinalization", fmt.Sprintf("clearing namespace finalizer on %q", c.namespaceName))
-	_, err = c.namespaceGetter.Namespaces().Finalize(ns)
+	_, err = c.namespaceGetter.Namespaces().Finalize(ctx, ns, metav1.UpdateOptions{})
 	return err
 }

pkg/operator/apiserver/controller/workload/workload.go

@@ -237,7 +237,7 @@ func (c *Controller) shouldSync(operatorSpec *operatorv1.OperatorSpec) (bool, er
 	case operatorv1.Unmanaged:
 		return false, nil
 	case operatorv1.Removed:
-		if err := c.kubeClient.CoreV1().Namespaces().Delete(c.targetNamespace, nil); err != nil && !apierrors.IsNotFound(err) {
+		if err := c.kubeClient.CoreV1().Namespaces().Delete(context.TODO(), c.targetNamespace, metav1.DeleteOptions{}); err != nil && !apierrors.IsNotFound(err) {
 			return false, err
 		}
 		return false, nil
@@ -249,7 +249,7 @@ func (c *Controller) shouldSync(operatorSpec *operatorv1.OperatorSpec) (bool, er
 
 // preconditionFulfilled checks if kube-apiserver is present and available
 func (c *Controller) preconditionFulfilled(operatorSpec *operatorv1.OperatorSpec) (bool, error) {
-	kubeAPIServerClusterOperator, err := c.openshiftClusterConfigClient.Get("kube-apiserver", metav1.GetOptions{})
+	kubeAPIServerClusterOperator, err := c.openshiftClusterConfigClient.Get(context.TODO(), "kube-apiserver", metav1.GetOptions{})
 	if apierrors.IsNotFound(err) {
 		message := "clusteroperator/kube-apiserver not found"
 		c.eventRecorder.Warning("PrereqNotReady", message)

pkg/operator/certrotation/config.go

@@ -1,6 +1,7 @@
 package certrotation
 
 import (
+	"context"
 	"fmt"
 	"time"
 
@@ -15,7 +16,7 @@ import (
 func GetCertRotationScale(client kubernetes.Interface, namespace string) (time.Duration, error) {
 	certRotationScale := time.Duration(0)
 	err := wait.PollImmediate(time.Second, 1*time.Minute, func() (bool, error) {
-		certRotationConfig, err := client.CoreV1().ConfigMaps(namespace).Get("unsupported-cert-rotation-config", metav1.GetOptions{})
+		certRotationConfig, err := client.CoreV1().ConfigMaps(namespace).Get(context.TODO(), "unsupported-cert-rotation-config", metav1.GetOptions{})
 		if err != nil {
 			if errors.IsNotFound(err) {
 				return true, nil

pkg/operator/encryption/controllers/key_controller.go

@@ -1,6 +1,7 @@
 package controllers
 
 import (
+	"context"
 	"encoding/base64"
 	"encoding/json"
 	"fmt"
@@ -201,7 +202,7 @@ func (c *keyController) checkAndCreateKeys() error {
 	if err != nil {
 		return fmt.Errorf("failed to create key: %v", err)
 	}
-	_, createErr := c.secretClient.Secrets("openshift-config-managed").Create(keySecret)
+	_, createErr := c.secretClient.Secrets("openshift-config-managed").Create(context.TODO(), keySecret, metav1.CreateOptions{})
 	if errors.IsAlreadyExists(createErr) {
 		return c.validateExistingSecret(keySecret, newKeyID)
 	}
@@ -216,7 +217,7 @@ func (c *keyController) checkAndCreateKeys() error {
 }
 
 func (c *keyController) validateExistingSecret(keySecret *corev1.Secret, keyID uint64) error {
-	actualKeySecret, err := c.secretClient.Secrets("openshift-config-managed").Get(keySecret.Name, metav1.GetOptions{})
+	actualKeySecret, err := c.secretClient.Secrets("openshift-config-managed").Get(context.TODO(), keySecret.Name, metav1.GetOptions{})
 	if err != nil {
 		return err
 	}
@@ -249,7 +250,7 @@ func (c *keyController) generateKeySecret(keyID uint64, currentMode state.Mode,
 }
 
 func (c *keyController) getCurrentModeAndExternalReason() (state.Mode, string, error) {
-	apiServer, err := c.apiServerClient.Get("cluster", metav1.GetOptions{})
+	apiServer, err := c.apiServerClient.Get(context.TODO(), "cluster", metav1.GetOptions{})
 	if err != nil {
 		return "", "", err
 	}

pkg/operator/encryption/controllers/migration_controller.go

@@ -1,6 +1,7 @@
 package controllers
 
 import (
+	"context"
 	"encoding/json"
 	"fmt"
 	"reflect"
@@ -249,7 +250,7 @@ func (c *migrationController) migrateKeysIfNeededAndRevisionStable() (migratingR
 			continue
 		}
 		if err := retry.RetryOnConflict(retry.DefaultBackoff, func() error {
-			s, err := c.secretClient.Secrets(oldWriteKey.Namespace).Get(oldWriteKey.Name, metav1.GetOptions{})
+			s, err := c.secretClient.Secrets(oldWriteKey.Namespace).Get(context.TODO(), oldWriteKey.Name, metav1.GetOptions{})
 			if err != nil {
 				return fmt.Errorf("failed to get key secret %s/%s: %v", oldWriteKey.Namespace, oldWriteKey.Name, err)
 			}

pkg/operator/encryption/controllers/migrators/inprocess.go

@@ -127,7 +127,7 @@ func (m *InProcessMigrator) runMigration(gvr schema.GroupVersionResource, writeK
 
 	listProcessor := newListProcessor(ctx, m.dynamicClient, func(obj *unstructured.Unstructured) error {
 		for {
-			_, updateErr := d.Namespace(obj.GetNamespace()).Update(obj, metav1.UpdateOptions{})
+			_, updateErr := d.Namespace(obj.GetNamespace()).Update(ctx, obj, metav1.UpdateOptions{})
 			if updateErr == nil || errors.IsNotFound(updateErr) || errors.IsConflict(updateErr) {
 				return nil
 			}

pkg/operator/encryption/controllers/migrators/inprocess_processor.go

@@ -50,7 +50,7 @@ func newListProcessor(ctx context.Context, dynamicClient dynamic.Interface, work
 func (p *listProcessor) run(gvr schema.GroupVersionResource) error {
 	listPager := pager.New(pager.SimplePageFunc(func(opts metav1.ListOptions) (runtime.Object, error) {
 		for {
-			allResource, err := p.dynamicClient.Resource(gvr).List(opts)
+			allResource, err := p.dynamicClient.Resource(gvr).List(context.TODO(), opts)
 			if err != nil {
 				klog.Warningf("List of %v failed: %v", gvr, err)
 				if errors.IsResourceExpired(err) {
@@ -87,7 +87,7 @@ func (p *listProcessor) run(gvr schema.GroupVersionResource) error {
 	listPager.FullListIfExpired = false // prevent memory explosion from full list
 
 	migrationStarted := time.Now()
-	if _, err := listPager.List(p.ctx, metav1.ListOptions{}); err != nil {
+	if _, _, err := listPager.List(p.ctx, metav1.ListOptions{}); err != nil {
 		metrics.ObserveFailedMigration(gvr.String())
 		return err
 	}

pkg/operator/encryption/controllers/migrators/kubestorageversionmigrator.go

@@ -1,6 +1,7 @@
 package migrators
 
 import (
+	"context"
 	"fmt"
 	"time"
 
@@ -52,7 +53,7 @@ func (m *KubeStorageVersionMigrator) EnsureMigration(gr schema.GroupResource, wr
 		}
 		return false, nil, time.Time{}, nil
 	} else if err == nil {
-		if err := m.client.MigrationV1alpha1().StorageVersionMigrations().Delete(name, &metav1.DeleteOptions{
+		if err := m.client.MigrationV1alpha1().StorageVersionMigrations().Delete(context.TODO(), name, metav1.DeleteOptions{
 			Preconditions: &metav1.Preconditions{ResourceVersion: &migration.ResourceVersion},
 		}); err != nil && !errors.IsNotFound(err) {
 			return false, nil, time.Time{}, err
@@ -64,7 +65,7 @@ func (m *KubeStorageVersionMigrator) EnsureMigration(gr schema.GroupResource, wr
 		return false, nil, time.Time{}, err
 	}
 
-	_, err = m.client.MigrationV1alpha1().StorageVersionMigrations().Create(&migrationv1alpha1.StorageVersionMigration{
+	_, err = m.client.MigrationV1alpha1().StorageVersionMigrations().Create(context.TODO(), &migrationv1alpha1.StorageVersionMigration{
 		ObjectMeta: metav1.ObjectMeta{
 			Name: name,
 			Annotations: map[string]string{
@@ -78,14 +79,14 @@ func (m *KubeStorageVersionMigrator) EnsureMigration(gr schema.GroupResource, wr
 				Resource: gr.Resource,
 			},
 		},
-	})
+	}, metav1.CreateOptions{})
 
 	return false, nil, time.Time{}, err
 }
 
 func (m *KubeStorageVersionMigrator) PruneMigration(gr schema.GroupResource) error {
 	name := migrationResourceName(gr)
-	if err := m.client.MigrationV1alpha1().StorageVersionMigrations().Delete(name, &metav1.DeleteOptions{}); err != nil && !errors.IsNotFound(err) {
+	if err := m.client.MigrationV1alpha1().StorageVersionMigrations().Delete(context.TODO(), name, metav1.DeleteOptions{}); err != nil && !errors.IsNotFound(err) {
 		return err
 	}
 	return nil