update dependencies

Signed-off-by: hongming <talonwan@yunify.com>

pkg/controller/application/application_controller.go

@@ -17,6 +17,7 @@ limitations under the License.
 package application
 
 import (
+	"context"
 	"fmt"
 	"time"
 
@@ -39,9 +40,9 @@ import (
 	servicemeshinformers "kubesphere.io/kubesphere/pkg/client/informers/externalversions/servicemesh/v1alpha2"
 	servicemeshlisters "kubesphere.io/kubesphere/pkg/client/listers/servicemesh/v1alpha2"
 	"kubesphere.io/kubesphere/pkg/controller/virtualservice/util"
-	applicationclient "sigs.k8s.io/application/pkg/client/clientset/versioned"
-	applicationinformers "sigs.k8s.io/application/pkg/client/informers/externalversions/app/v1beta1"
-	applicationlister "sigs.k8s.io/application/pkg/client/listers/app/v1beta1"
+	applicationclient "kubesphere.io/kubesphere/pkg/simple/client/app/clientset/versioned"
+	applicationinformers "kubesphere.io/kubesphere/pkg/simple/client/app/informers/externalversions/app/v1beta1"
+	applicationlister "kubesphere.io/kubesphere/pkg/simple/client/app/listers/app/v1beta1"
 )
 
 const (
@@ -232,7 +233,7 @@ func (v *ApplicationController) syncApplication(key string) error {
 	annotations["kubesphere.io/last-updated"] = time.Now().String()
 	application.SetAnnotations(annotations)
 
-	_, err = v.applicationClient.AppV1beta1().Applications(namespace).Update(application)
+	_, err = v.applicationClient.AppV1beta1().Applications(namespace).Update(context.Background(), application, metav1.UpdateOptions{})
 	if err != nil {
 		if errors.IsNotFound(err) {
 			log.V(4).Info("application has been deleted during update")

pkg/controller/certificatesigningrequest/certificatesigningrequest_controller.go

@@ -17,6 +17,7 @@ limitations under the License.
 package certificatesigningrequest
 
 import (
+	"context"
 	"fmt"
 	certificatesv1beta1 "k8s.io/api/certificates/v1beta1"
 	corev1 "k8s.io/api/core/v1"
@@ -225,7 +226,7 @@ func (c *Controller) reconcile(key string) error {
 				return err
 			}
 			// release
-			err := c.k8sclient.CertificatesV1beta1().CertificateSigningRequests().Delete(csr.Name, metav1.NewDeleteOptions(0))
+			err := c.k8sclient.CertificatesV1beta1().CertificateSigningRequests().Delete(context.Background(), csr.Name, *metav1.NewDeleteOptions(0))
 			if err != nil {
 				klog.Error(err)
 				return err
@@ -258,7 +259,7 @@ func (c *Controller) Approve(csr *certificatesv1beta1.CertificateSigningRequest)
 	}
 
 	// approve csr
-	csr, err := c.k8sclient.CertificatesV1beta1().CertificateSigningRequests().UpdateApproval(csr)
+	csr, err := c.k8sclient.CertificatesV1beta1().CertificateSigningRequests().UpdateApproval(context.Background(), csr, metav1.UpdateOptions{})
 	if err != nil {
 		klog.Errorln(err)
 		return err

pkg/controller/cluster/join.go

@@ -147,7 +147,7 @@ func performPreflightChecks(clusterClientset kubeclient.Interface, name, hostClu
 	kubefedNamespace string, errorOnExisting bool) error {
 	// Make sure there is no existing service account in the joining cluster.
 	saName := util.ClusterServiceAccountName(name, hostClusterName)
-	_, err := clusterClientset.CoreV1().ServiceAccounts(kubefedNamespace).Get(saName, metav1.GetOptions{})
+	_, err := clusterClientset.CoreV1().ServiceAccounts(kubefedNamespace).Get(context.Background(), saName, metav1.GetOptions{})
 
 	switch {
 	case apierrors.IsNotFound(err):
@@ -237,7 +237,7 @@ func createKubeFedNamespace(clusterClientset kubeclient.Interface, kubefedNamesp
 		return fedNamespace, nil
 	}
 
-	_, err := clusterClientset.CoreV1().Namespaces().Get(kubefedNamespace, metav1.GetOptions{})
+	_, err := clusterClientset.CoreV1().Namespaces().Get(context.Background(), kubefedNamespace, metav1.GetOptions{})
 	if err != nil && !apierrors.IsNotFound(err) {
 		klog.V(2).Infof("Could not get %s namespace: %v", kubefedNamespace, err)
 		return nil, err
@@ -249,7 +249,7 @@ func createKubeFedNamespace(clusterClientset kubeclient.Interface, kubefedNamesp
 	}
 
 	// Not found, so create.
-	_, err = clusterClientset.CoreV1().Namespaces().Create(fedNamespace)
+	_, err = clusterClientset.CoreV1().Namespaces().Create(context.Background(), fedNamespace, metav1.CreateOptions{})
 	if err != nil && !apierrors.IsAlreadyExists(err) {
 		klog.V(2).Infof("Could not create %s namespace: %v", kubefedNamespace, err)
 		return nil, err
@@ -337,7 +337,7 @@ func createServiceAccount(clusterClientset kubeclient.Interface, namespace,
 	}
 
 	// Create a new service account.
-	_, err := clusterClientset.CoreV1().ServiceAccounts(namespace).Create(sa)
+	_, err := clusterClientset.CoreV1().ServiceAccounts(namespace).Create(context.Background(), sa, metav1.CreateOptions{})
 	switch {
 	case apierrors.IsAlreadyExists(err) && errorOnExisting:
 		klog.V(2).Infof("Service account %s/%s already exists in target cluster %s", namespace, saName, joiningClusterName)
@@ -377,7 +377,7 @@ func createClusterRoleAndBinding(clientset kubeclient.Interface, saName, namespa
 		},
 		Rules: clusterPolicyRules,
 	}
-	existingRole, err := clientset.RbacV1().ClusterRoles().Get(roleName, metav1.GetOptions{})
+	existingRole, err := clientset.RbacV1().ClusterRoles().Get(context.Background(), roleName, metav1.GetOptions{})
 	switch {
 	case err != nil && !apierrors.IsNotFound(err):
 		klog.V(2).Infof("Could not get cluster role for service account %s in joining cluster %s due to %v",
@@ -387,14 +387,14 @@ func createClusterRoleAndBinding(clientset kubeclient.Interface, saName, namespa
 		return errors.Errorf("cluster role for service account %s in joining cluster %s already exists", saName, clusterName)
 	case err == nil:
 		existingRole.Rules = role.Rules
-		_, err := clientset.RbacV1().ClusterRoles().Update(existingRole)
+		_, err := clientset.RbacV1().ClusterRoles().Update(context.Background(), existingRole, metav1.UpdateOptions{})
 		if err != nil {
 			klog.V(2).Infof("Could not update cluster role for service account: %s in joining cluster: %s due to: %v",
 				saName, clusterName, err)
 			return err
 		}
 	default: // role was not found
-		_, err := clientset.RbacV1().ClusterRoles().Create(role)
+		_, err := clientset.RbacV1().ClusterRoles().Create(context.Background(), role, metav1.CreateOptions{})
 		if err != nil {
 			klog.V(2).Infof("Could not create cluster role for service account: %s in joining cluster: %s due to: %v",
 				saName, clusterName, err)
@@ -414,7 +414,7 @@ func createClusterRoleAndBinding(clientset kubeclient.Interface, saName, namespa
 			Name:     roleName,
 		},
 	}
-	existingBinding, err := clientset.RbacV1().ClusterRoleBindings().Get(binding.Name, metav1.GetOptions{})
+	existingBinding, err := clientset.RbacV1().ClusterRoleBindings().Get(context.Background(), binding.Name, metav1.GetOptions{})
 	switch {
 	case err != nil && !apierrors.IsNotFound(err):
 		klog.V(2).Infof("Could not get cluster role binding for service account %s in joining cluster %s due to %v",
@@ -426,13 +426,13 @@ func createClusterRoleAndBinding(clientset kubeclient.Interface, saName, namespa
 		// The roleRef cannot be updated, therefore if the existing roleRef is different, the existing rolebinding
 		// must be deleted and recreated with the correct roleRef
 		if !reflect.DeepEqual(existingBinding.RoleRef, binding.RoleRef) {
-			err = clientset.RbacV1().ClusterRoleBindings().Delete(existingBinding.Name, &metav1.DeleteOptions{})
+			err = clientset.RbacV1().ClusterRoleBindings().Delete(context.Background(), existingBinding.Name, metav1.DeleteOptions{})
 			if err != nil {
 				klog.V(2).Infof("Could not delete existing cluster role binding for service account %s in joining cluster %s due to: %v",
 					saName, clusterName, err)
 				return err
 			}
-			_, err = clientset.RbacV1().ClusterRoleBindings().Create(binding)
+			_, err = clientset.RbacV1().ClusterRoleBindings().Create(context.Background(), binding, metav1.CreateOptions{})
 			if err != nil {
 				klog.V(2).Infof("Could not create cluster role binding for service account: %s in joining cluster: %s due to: %v",
 					saName, clusterName, err)
@@ -440,7 +440,7 @@ func createClusterRoleAndBinding(clientset kubeclient.Interface, saName, namespa
 			}
 		} else {
 			existingBinding.Subjects = binding.Subjects
-			_, err := clientset.RbacV1().ClusterRoleBindings().Update(existingBinding)
+			_, err := clientset.RbacV1().ClusterRoleBindings().Update(context.Background(), existingBinding, metav1.UpdateOptions{})
 			if err != nil {
 				klog.V(2).Infof("Could not update cluster role binding for service account: %s in joining cluster: %s due to: %v",
 					saName, clusterName, err)
@@ -448,7 +448,7 @@ func createClusterRoleAndBinding(clientset kubeclient.Interface, saName, namespa
 			}
 		}
 	default:
-		_, err = clientset.RbacV1().ClusterRoleBindings().Create(binding)
+		_, err = clientset.RbacV1().ClusterRoleBindings().Create(context.Background(), binding, metav1.CreateOptions{})
 		if err != nil {
 			klog.V(2).Infof("Could not create cluster role binding for service account: %s in joining cluster: %s due to: %v",
 				saName, clusterName, err)
@@ -474,7 +474,7 @@ func createRoleAndBinding(clientset kubeclient.Interface, saName, namespace, clu
 		},
 		Rules: namespacedPolicyRules,
 	}
-	existingRole, err := clientset.RbacV1().Roles(namespace).Get(roleName, metav1.GetOptions{})
+	existingRole, err := clientset.RbacV1().Roles(namespace).Get(context.Background(), roleName, metav1.GetOptions{})
 	switch {
 	case err != nil && !apierrors.IsNotFound(err):
 		klog.V(2).Infof("Could not retrieve role for service account %s in joining cluster %s due to %v", saName, clusterName, err)
@@ -483,14 +483,14 @@ func createRoleAndBinding(clientset kubeclient.Interface, saName, namespace, clu
 		return errors.Errorf("role for service account %s in joining cluster %s already exists", saName, clusterName)
 	case err == nil:
 		existingRole.Rules = role.Rules
-		_, err = clientset.RbacV1().Roles(namespace).Update(existingRole)
+		_, err = clientset.RbacV1().Roles(namespace).Update(context.Background(), existingRole, metav1.UpdateOptions{})
 		if err != nil {
 			klog.V(2).Infof("Could not update role for service account: %s in joining cluster: %s due to: %v",
 				saName, clusterName, err)
 			return err
 		}
 	default:
-		_, err := clientset.RbacV1().Roles(namespace).Create(role)
+		_, err := clientset.RbacV1().Roles(namespace).Create(context.Background(), role, metav1.CreateOptions{})
 		if err != nil {
 			klog.V(2).Infof("Could not create role for service account: %s in joining cluster: %s due to: %v",
 				saName, clusterName, err)
@@ -510,7 +510,7 @@ func createRoleAndBinding(clientset kubeclient.Interface, saName, namespace, clu
 		},
 	}
 
-	existingBinding, err := clientset.RbacV1().RoleBindings(namespace).Get(binding.Name, metav1.GetOptions{})
+	existingBinding, err := clientset.RbacV1().RoleBindings(namespace).Get(context.Background(), binding.Name, metav1.GetOptions{})
 	switch {
 	case err != nil && !apierrors.IsNotFound(err):
 		klog.V(2).Infof("Could not retrieve role binding for service account %s in joining cluster %s due to: %v",
@@ -522,13 +522,13 @@ func createRoleAndBinding(clientset kubeclient.Interface, saName, namespace, clu
 		// The roleRef cannot be updated, therefore if the existing roleRef is different, the existing rolebinding
 		// must be deleted and recreated with the correct roleRef
 		if !reflect.DeepEqual(existingBinding.RoleRef, binding.RoleRef) {
-			err = clientset.RbacV1().RoleBindings(namespace).Delete(existingBinding.Name, &metav1.DeleteOptions{})
+			err = clientset.RbacV1().RoleBindings(namespace).Delete(context.Background(), existingBinding.Name, metav1.DeleteOptions{})
 			if err != nil {
 				klog.V(2).Infof("Could not delete existing role binding for service account %s in joining cluster %s due to: %v",
 					saName, clusterName, err)
 				return err
 			}
-			_, err = clientset.RbacV1().RoleBindings(namespace).Create(binding)
+			_, err = clientset.RbacV1().RoleBindings(namespace).Create(context.Background(), binding, metav1.CreateOptions{})
 			if err != nil {
 				klog.V(2).Infof("Could not create role binding for service account: %s in joining cluster: %s due to: %v",
 					saName, clusterName, err)
@@ -536,7 +536,7 @@ func createRoleAndBinding(clientset kubeclient.Interface, saName, namespace, clu
 			}
 		} else {
 			existingBinding.Subjects = binding.Subjects
-			_, err = clientset.RbacV1().RoleBindings(namespace).Update(existingBinding)
+			_, err = clientset.RbacV1().RoleBindings(namespace).Update(context.Background(), existingBinding, metav1.UpdateOptions{})
 			if err != nil {
 				klog.V(2).Infof("Could not update role binding for service account %s in joining cluster %s due to: %v",
 					saName, clusterName, err)
@@ -544,7 +544,7 @@ func createRoleAndBinding(clientset kubeclient.Interface, saName, namespace, clu
 			}
 		}
 	default:
-		_, err = clientset.RbacV1().RoleBindings(namespace).Create(binding)
+		_, err = clientset.RbacV1().RoleBindings(namespace).Create(context.Background(), binding, metav1.CreateOptions{})
 		if err != nil {
 			klog.V(2).Infof("Could not create role binding for service account: %s in joining cluster: %s due to: %v",
 				saName, clusterName, err)
@@ -583,7 +583,7 @@ func createHealthCheckClusterRoleAndBinding(clientset kubeclient.Interface, saNa
 			},
 		},
 	}
-	existingRole, err := clientset.RbacV1().ClusterRoles().Get(role.Name, metav1.GetOptions{})
+	existingRole, err := clientset.RbacV1().ClusterRoles().Get(context.Background(), role.Name, metav1.GetOptions{})
 	switch {
 	case err != nil && !apierrors.IsNotFound(err):
 		klog.V(2).Infof("Could not get health check cluster role for service account %s in joining cluster %s due to %v",
@@ -593,14 +593,14 @@ func createHealthCheckClusterRoleAndBinding(clientset kubeclient.Interface, saNa
 		return errors.Errorf("health check cluster role for service account %s in joining cluster %s already exists", saName, clusterName)
 	case err == nil:
 		existingRole.Rules = role.Rules
-		_, err := clientset.RbacV1().ClusterRoles().Update(existingRole)
+		_, err := clientset.RbacV1().ClusterRoles().Update(context.Background(), existingRole, metav1.UpdateOptions{})
 		if err != nil {
 			klog.V(2).Infof("Could not update health check cluster role for service account: %s in joining cluster: %s due to: %v",
 				saName, clusterName, err)
 			return err
 		}
 	default: // role was not found
-		_, err := clientset.RbacV1().ClusterRoles().Create(role)
+		_, err := clientset.RbacV1().ClusterRoles().Create(context.Background(), role, metav1.CreateOptions{})
 		if err != nil {
 			klog.V(2).Infof("Could not create health check cluster role for service account: %s in joining cluster: %s due to: %v",
 				saName, clusterName, err)
@@ -619,7 +619,7 @@ func createHealthCheckClusterRoleAndBinding(clientset kubeclient.Interface, saNa
 			Name:     roleName,
 		},
 	}
-	existingBinding, err := clientset.RbacV1().ClusterRoleBindings().Get(binding.Name, metav1.GetOptions{})
+	existingBinding, err := clientset.RbacV1().ClusterRoleBindings().Get(context.Background(), binding.Name, metav1.GetOptions{})
 	switch {
 	case err != nil && !apierrors.IsNotFound(err):
 		klog.V(2).Infof("Could not get health check cluster role binding for service account %s in joining cluster %s due to %v",
@@ -631,13 +631,13 @@ func createHealthCheckClusterRoleAndBinding(clientset kubeclient.Interface, saNa
 		// The roleRef cannot be updated, therefore if the existing roleRef is different, the existing rolebinding
 		// must be deleted and recreated with the correct roleRef
 		if !reflect.DeepEqual(existingBinding.RoleRef, binding.RoleRef) {
-			err = clientset.RbacV1().ClusterRoleBindings().Delete(existingBinding.Name, &metav1.DeleteOptions{})
+			err = clientset.RbacV1().ClusterRoleBindings().Delete(context.Background(), existingBinding.Name, metav1.DeleteOptions{})
 			if err != nil {
 				klog.V(2).Infof("Could not delete existing health check cluster role binding for service account %s in joining cluster %s due to: %v",
 					saName, clusterName, err)
 				return err
 			}
-			_, err = clientset.RbacV1().ClusterRoleBindings().Create(binding)
+			_, err = clientset.RbacV1().ClusterRoleBindings().Create(context.Background(), binding, metav1.CreateOptions{})
 			if err != nil {
 				klog.V(2).Infof("Could not create health check cluster role binding for service account: %s in joining cluster: %s due to: %v",
 					saName, clusterName, err)
@@ -645,7 +645,7 @@ func createHealthCheckClusterRoleAndBinding(clientset kubeclient.Interface, saNa
 			}
 		} else {
 			existingBinding.Subjects = binding.Subjects
-			_, err := clientset.RbacV1().ClusterRoleBindings().Update(existingBinding)
+			_, err := clientset.RbacV1().ClusterRoleBindings().Update(context.Background(), existingBinding, metav1.UpdateOptions{})
 			if err != nil {
 				klog.V(2).Infof("Could not update health check cluster role binding for service account: %s in joining cluster: %s due to: %v",
 					saName, clusterName, err)
@@ -653,7 +653,7 @@ func createHealthCheckClusterRoleAndBinding(clientset kubeclient.Interface, saNa
 			}
 		}
 	default:
-		_, err = clientset.RbacV1().ClusterRoleBindings().Create(binding)
+		_, err = clientset.RbacV1().ClusterRoleBindings().Create(context.Background(), binding, metav1.CreateOptions{})
 		if err != nil {
 			klog.V(2).Infof("Could not create health check cluster role binding for service account: %s in joining cluster: %s due to: %v",
 				saName, clusterName, err)
@@ -682,7 +682,7 @@ func populateSecretInHostCluster(clusterClientset, hostClientset kubeclient.Inte
 	// Get the secret from the joining cluster.
 	var secret *corev1.Secret
 	err := wait.PollImmediate(1*time.Second, serviceAccountSecretTimeout, func() (bool, error) {
-		sa, err := clusterClientset.CoreV1().ServiceAccounts(joiningNamespace).Get(saName,
+		sa, err := clusterClientset.CoreV1().ServiceAccounts(joiningNamespace).Get(context.Background(), saName,
 			metav1.GetOptions{})
 		if err != nil {
 			return false, nil
@@ -691,7 +691,7 @@ func populateSecretInHostCluster(clusterClientset, hostClientset kubeclient.Inte
 		for _, objReference := range sa.Secrets {
 			saSecretName := objReference.Name
 			var err error
-			secret, err = clusterClientset.CoreV1().Secrets(joiningNamespace).Get(saSecretName, metav1.GetOptions{})
+			secret, err = clusterClientset.CoreV1().Secrets(joiningNamespace).Get(context.Background(), saSecretName, metav1.GetOptions{})
 			if err != nil {
 				return false, nil
 			}
@@ -730,10 +730,10 @@ func populateSecretInHostCluster(clusterClientset, hostClientset kubeclient.Inte
 	}
 
 	var v1SecretResult *corev1.Secret
-	_, err = hostClientset.CoreV1().Secrets(hostNamespace).Get(v1Secret.Name, metav1.GetOptions{})
+	_, err = hostClientset.CoreV1().Secrets(hostNamespace).Get(context.Background(), v1Secret.Name, metav1.GetOptions{})
 	if err != nil {
 		if apierrors.IsNotFound(err) {
-			v1SecretResult, err = hostClientset.CoreV1().Secrets(hostNamespace).Create(&v1Secret)
+			v1SecretResult, err = hostClientset.CoreV1().Secrets(hostNamespace).Create(context.Background(), &v1Secret, metav1.CreateOptions{})
 			if err != nil {
 				klog.V(2).Infof("Could not create secret in host cluster: %v", err)
 				return nil, nil, err
@@ -743,7 +743,7 @@ func populateSecretInHostCluster(clusterClientset, hostClientset kubeclient.Inte
 		klog.V(2).Infof("Could not get secret %s in host cluster: %v", v1Secret.Name, err)
 		return nil, nil, err
 	} else {
-		v1SecretResult, err = hostClientset.CoreV1().Secrets(hostNamespace).Update(&v1Secret)
+		v1SecretResult, err = hostClientset.CoreV1().Secrets(hostNamespace).Update(context.Background(), &v1Secret, metav1.UpdateOptions{})
 		if err != nil {
 			klog.V(2).Infof("Update secret %s in host cluster failed: %v", v1Secret.Name, err)
 			return nil, nil, err

pkg/controller/cluster/unjoin.go

@@ -105,8 +105,8 @@ func deleteFederatedClusterAndSecret(hostClientset kubeclient.Interface, client
 		return errors.Wrapf(err, "Failed to get kubefed cluster \"%s/%s\"", kubefedNamespace, unjoiningClusterName)
 	}
 
-	err = hostClientset.CoreV1().Secrets(kubefedNamespace).Delete(fedCluster.Spec.SecretRef.Name,
-		&metav1.DeleteOptions{})
+	err = hostClientset.CoreV1().Secrets(kubefedNamespace).Delete(context.Background(), fedCluster.Spec.SecretRef.Name,
+		metav1.DeleteOptions{})
 	if apierrors.IsNotFound(err) {
 		klog.V(2).Infof("Secret \"%s/%s\" does not exist in the host cluster.", kubefedNamespace, fedCluster.Spec.SecretRef.Name)
 	} else if err != nil {
@@ -166,12 +166,12 @@ func deleteFedNSFromUnjoinCluster(hostClientset, unjoiningClusterClientset kubec
 		return nil
 	}
 
-	hostClusterNamespace, err := hostClientset.CoreV1().Namespaces().Get(kubefedNamespace, metav1.GetOptions{})
+	hostClusterNamespace, err := hostClientset.CoreV1().Namespaces().Get(context.Background(), kubefedNamespace, metav1.GetOptions{})
 	if err != nil {
 		return errors.Wrapf(err, "Error retrieving namespace %q from host cluster", kubefedNamespace)
 	}
 
-	unjoiningClusterNamespace, err := unjoiningClusterClientset.CoreV1().Namespaces().Get(kubefedNamespace, metav1.GetOptions{})
+	unjoiningClusterNamespace, err := unjoiningClusterClientset.CoreV1().Namespaces().Get(context.Background(), kubefedNamespace, metav1.GetOptions{})
 	if err != nil {
 		return errors.Wrapf(err, "Error retrieving namespace %q from unjoining cluster %q", kubefedNamespace, unjoiningClusterName)
 	}
@@ -182,7 +182,7 @@ func deleteFedNSFromUnjoinCluster(hostClientset, unjoiningClusterClientset kubec
 	}
 
 	klog.V(2).Infof("Deleting kubefed namespace %q from unjoining cluster %q.", kubefedNamespace, unjoiningClusterName)
-	err = unjoiningClusterClientset.CoreV1().Namespaces().Delete(kubefedNamespace, &metav1.DeleteOptions{})
+	err = unjoiningClusterClientset.CoreV1().Namespaces().Delete(context.Background(), kubefedNamespace, metav1.DeleteOptions{})
 	if apierrors.IsNotFound(err) {
 		klog.V(2).Infof("The kubefed namespace %q no longer exists in unjoining cluster %q.", kubefedNamespace, unjoiningClusterName)
 		return nil
@@ -207,8 +207,8 @@ func deleteServiceAccount(clusterClientset kubeclient.Interface, saName,
 	klog.V(2).Infof("Deleting service account \"%s/%s\" in unjoining cluster %q.", namespace, saName, unjoiningClusterName)
 
 	// Delete a service account.
-	err := clusterClientset.CoreV1().ServiceAccounts(namespace).Delete(saName,
-		&metav1.DeleteOptions{})
+	err := clusterClientset.CoreV1().ServiceAccounts(namespace).Delete(context.Background(), saName,
+		metav1.DeleteOptions{})
 	if apierrors.IsNotFound(err) {
 		klog.V(2).Infof("Service account \"%s/%s\" does not exist.", namespace, saName)
 	} else if err != nil {
@@ -237,7 +237,7 @@ func deleteClusterRoleAndBinding(clusterClientset kubeclient.Interface,
 		klog.V(2).Infof("Deleting cluster role binding %q for service account %q in unjoining cluster %q.",
 			name, saName, unjoiningClusterName)
 
-		err := clusterClientset.RbacV1().ClusterRoleBindings().Delete(name, &metav1.DeleteOptions{})
+		err := clusterClientset.RbacV1().ClusterRoleBindings().Delete(context.Background(), name, metav1.DeleteOptions{})
 		if apierrors.IsNotFound(err) {
 			klog.V(2).Infof("Cluster role binding %q for service account %q does not exist in unjoining cluster %q.",
 				name, saName, unjoiningClusterName)
@@ -255,7 +255,7 @@ func deleteClusterRoleAndBinding(clusterClientset kubeclient.Interface,
 
 		klog.V(2).Infof("Deleting cluster role %q for service account %q in unjoining cluster %q.",
 			name, saName, unjoiningClusterName)
-		err = clusterClientset.RbacV1().ClusterRoles().Delete(name, &metav1.DeleteOptions{})
+		err = clusterClientset.RbacV1().ClusterRoles().Delete(context.Background(), name, metav1.DeleteOptions{})
 		if apierrors.IsNotFound(err) {
 			klog.V(2).Infof("Cluster role %q for service account %q does not exist in unjoining cluster %q.",
 				name, saName, unjoiningClusterName)
@@ -274,7 +274,7 @@ func deleteClusterRoleAndBinding(clusterClientset kubeclient.Interface,
 
 	klog.V(2).Infof("Deleting role binding \"%s/%s\" for service account %q in unjoining cluster %q.",
 		namespace, roleName, saName, unjoiningClusterName)
-	err := clusterClientset.RbacV1().RoleBindings(namespace).Delete(roleName, &metav1.DeleteOptions{})
+	err := clusterClientset.RbacV1().RoleBindings(namespace).Delete(context.Background(), roleName, metav1.DeleteOptions{})
 	if apierrors.IsNotFound(err) {
 		klog.V(2).Infof("Role binding \"%s/%s\" for service account %q does not exist in unjoining cluster %q.",
 			namespace, roleName, saName, unjoiningClusterName)
@@ -292,7 +292,7 @@ func deleteClusterRoleAndBinding(clusterClientset kubeclient.Interface,
 
 	klog.V(2).Infof("Deleting role \"%s/%s\" for service account %q in unjoining cluster %q.",
 		namespace, roleName, saName, unjoiningClusterName)
-	err = clusterClientset.RbacV1().Roles(namespace).Delete(roleName, &metav1.DeleteOptions{})
+	err = clusterClientset.RbacV1().Roles(namespace).Delete(context.Background(), roleName, metav1.DeleteOptions{})
 	if apierrors.IsNotFound(err) {
 		klog.V(2).Infof("Role \"%s/%s\" for service account %q does not exist in unjoining cluster %q.",
 			namespace, roleName, saName, unjoiningClusterName)

pkg/controller/destinationrule/destinationrule_controller.go

@@ -17,6 +17,7 @@ limitations under the License.
 package destinationrule
 
 import (
+	"context"
 	"fmt"
 	"reflect"
 
@@ -226,14 +227,14 @@ func (v *DestinationRuleController) syncService(key string) error {
 	service, err := v.serviceLister.Services(namespace).Get(name)
 	if err != nil {
 		// delete the corresponding destinationrule if there is any, as the service has been deleted.
-		err = v.destinationRuleClient.NetworkingV1alpha3().DestinationRules(namespace).Delete(name, nil)
+		err = v.destinationRuleClient.NetworkingV1alpha3().DestinationRules(namespace).Delete(context.Background(), name, metav1.DeleteOptions{})
 		if err != nil && !errors.IsNotFound(err) {
 			log.Errorf("delete destination rule failed %s/%s, error %v.", namespace, name, err)
 			return err
 		}
 
 		// delete orphan service policy if there is any
-		err = v.servicemeshClient.ServicemeshV1alpha2().ServicePolicies(namespace).Delete(name, nil)
+		err = v.servicemeshClient.ServicemeshV1alpha2().ServicePolicies(namespace).Delete(context.Background(), name, metav1.DeleteOptions{})
 		if err != nil && !errors.IsNotFound(err) {
 			log.Errorf("delete orphan service policy %s/%s failed, %#v", namespace, name, err)
 			return err
@@ -355,9 +356,9 @@ func (v *DestinationRuleController) syncService(key string) error {
 	}
 
 	if createDestinationRule {
-		_, err = v.destinationRuleClient.NetworkingV1alpha3().DestinationRules(namespace).Create(newDestinationRule)
+		_, err = v.destinationRuleClient.NetworkingV1alpha3().DestinationRules(namespace).Create(context.Background(), newDestinationRule, metav1.CreateOptions{})
 	} else {
-		_, err = v.destinationRuleClient.NetworkingV1alpha3().DestinationRules(namespace).Update(newDestinationRule)
+		_, err = v.destinationRuleClient.NetworkingV1alpha3().DestinationRules(namespace).Update(context.Background(), newDestinationRule, metav1.UpdateOptions{})
 	}
 
 	if err != nil {

pkg/controller/destinationrule/destinationrule_controller_test.go

@@ -17,6 +17,7 @@ limitations under the License.
 package destinationrule
 
 import (
+	"context"
 	"fmt"
 	apiv1alpha3 "istio.io/api/networking/v1alpha3"
 	"istio.io/client-go/pkg/apis/networking/v1alpha3"
@@ -297,7 +298,7 @@ func (f *fixture) run(service *corev1.Service, expected *v1alpha3.DestinationRul
 		f.t.Fatal("expected error syncing service, got nil")
 	}
 
-	got, err := c.destinationRuleClient.NetworkingV1alpha3().DestinationRules(service.Namespace).Get(service.Name, metav1.GetOptions{})
+	got, err := c.destinationRuleClient.NetworkingV1alpha3().DestinationRules(service.Namespace).Get(context.Background(), service.Name, metav1.GetOptions{})
 	if err != nil {
 		f.t.Fatal(err)
 	}

pkg/controller/devopscredential/devopscredential_controller.go

@@ -17,9 +17,11 @@ limitations under the License.
 package devopscredential
 
 import (
+	"context"
 	"fmt"
 	v1 "k8s.io/api/core/v1"
 	"k8s.io/apimachinery/pkg/api/errors"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	utilruntime "k8s.io/apimachinery/pkg/util/runtime"
 	"k8s.io/apimachinery/pkg/util/wait"
 	corev1informer "k8s.io/client-go/informers/core/v1"
@@ -277,7 +279,7 @@ func (c *Controller) syncHandler(key string) error {
 		}
 	}
 	if !reflect.DeepEqual(secret, copySecret) {
-		_, err = c.client.CoreV1().Secrets(nsName).Update(copySecret)
+		_, err = c.client.CoreV1().Secrets(nsName).Update(context.Background(), copySecret, metav1.UpdateOptions{})
 		if err != nil {
 			klog.V(8).Info(err, fmt.Sprintf("failed to update secret %s ", key))
 			return err

pkg/controller/devopsproject/devopsproject_controller.go

@@ -17,6 +17,7 @@ limitations under the License.
 package devopsproject
 
 import (
+	"context"
 	"fmt"
 	"github.com/emicklei/go-restful"
 	v1 "k8s.io/api/core/v1"
@@ -237,7 +238,7 @@ func (c *Controller) syncHandler(key string) error {
 			} else if errors.IsNotFound(err) {
 				// if admin ns is not found, clean project status, rerun reconcile
 				copyProject.Status.AdminNamespace = ""
-				_, err := c.kubesphereClient.DevopsV1alpha3().DevOpsProjects().Update(copyProject)
+				_, err := c.kubesphereClient.DevopsV1alpha3().DevOpsProjects().Update(context.Background(), copyProject, metav1.UpdateOptions{})
 				if err != nil {
 					klog.V(8).Info(err, fmt.Sprintf("failed to update project %s ", key))
 					return err
@@ -258,7 +259,7 @@ func (c *Controller) syncHandler(key string) error {
 					return err
 				}
 				copyNs.Labels[constants.DevOpsProjectLabelKey] = project.Name
-				_, err = c.client.CoreV1().Namespaces().Update(copyNs)
+				_, err = c.client.CoreV1().Namespaces().Update(context.Background(), copyNs, metav1.UpdateOptions{})
 				if err != nil {
 					klog.V(8).Info(err, fmt.Sprintf("failed to update ns %s ", key))
 					return err
@@ -276,7 +277,7 @@ func (c *Controller) syncHandler(key string) error {
 			// if there is no ns, generate new one
 			if len(namespaces) == 0 {
 				ns := c.generateNewNamespace(project)
-				ns, err := c.client.CoreV1().Namespaces().Create(ns)
+				ns, err := c.client.CoreV1().Namespaces().Create(context.Background(), ns, metav1.CreateOptions{})
 				if err != nil {
 					// devops project name is conflict, cannot create admin namespace
 					if errors.IsAlreadyExists(err) {
@@ -300,7 +301,7 @@ func (c *Controller) syncHandler(key string) error {
 						return err
 					}
 					copyNs.Labels[constants.DevOpsProjectLabelKey] = project.Name
-					_, err = c.client.CoreV1().Namespaces().Update(copyNs)
+					_, err = c.client.CoreV1().Namespaces().Update(context.Background(), copyNs, metav1.UpdateOptions{})
 					if err != nil {
 						klog.V(8).Info(err, fmt.Sprintf("failed to update ns %s ", key))
 						return err
@@ -332,7 +333,7 @@ func (c *Controller) syncHandler(key string) error {
 		}
 		copyProject.Annotations[devopsv1alpha3.DevOpeProjectSyncStatusAnnoKey] = modelsdevops.StatusSuccessful
 		if !reflect.DeepEqual(copyProject, project) {
-			copyProject, err = c.kubesphereClient.DevopsV1alpha3().DevOpsProjects().Update(copyProject)
+			copyProject, err = c.kubesphereClient.DevopsV1alpha3().DevOpsProjects().Update(context.Background(), copyProject, metav1.UpdateOptions{})
 			if err != nil {
 				klog.V(8).Info(err, fmt.Sprintf("failed to update ns %s ", key))
 				return err
@@ -368,7 +369,7 @@ func (c *Controller) syncHandler(key string) error {
 				return fmt.Errorf("failed to remove devopsproject finalizer due to bad communication with Jenkins")
 			}
 
-			_, err = c.kubesphereClient.DevopsV1alpha3().DevOpsProjects().Update(project)
+			_, err = c.kubesphereClient.DevopsV1alpha3().DevOpsProjects().Update(context.Background(), project, metav1.UpdateOptions{})
 			if err != nil {
 				klog.V(8).Info(err, fmt.Sprintf("failed to update project %s ", key))
 				return err
@@ -405,7 +406,7 @@ func (c *Controller) bindWorkspace(project *devopsv1alpha3.DevOpsProject) (*devo
 			return nil, err
 		}
 
-		return c.kubesphereClient.DevopsV1alpha3().DevOpsProjects().Update(project)
+		return c.kubesphereClient.DevopsV1alpha3().DevOpsProjects().Update(context.Background(), project, metav1.UpdateOptions{})
 	}
 
 	return project, nil

pkg/controller/globalrole/globalrole_controller.go

@@ -17,6 +17,7 @@ limitations under the License.
 package globalrole
 
 import (
+	"context"
 	"encoding/json"
 	"fmt"
 	corev1 "k8s.io/api/core/v1"
@@ -214,7 +215,7 @@ func (c *Controller) reconcile(key string) error {
 		return err
 	}
 
-	if err = c.multiClusterSync(globalRole); err != nil {
+	if err = c.multiClusterSync(context.Background(), globalRole); err != nil {
 		klog.Error(err)
 		return err
 	}
@@ -227,16 +228,16 @@ func (c *Controller) Start(stopCh <-chan struct{}) error {
 	return c.Run(4, stopCh)
 }
 
-func (c *Controller) multiClusterSync(globalRole *iamv1alpha2.GlobalRole) error {
+func (c *Controller) multiClusterSync(ctx context.Context, globalRole *iamv1alpha2.GlobalRole) error {
 
-	if err := c.ensureNotControlledByKubefed(globalRole); err != nil {
+	if err := c.ensureNotControlledByKubefed(ctx, globalRole); err != nil {
 		klog.Error(err)
 		return err
 	}
 
 	obj, exist, err := c.fedGlobalRoleCache.GetByKey(globalRole.Name)
 	if !exist {
-		return c.createFederatedGlobalRole(globalRole)
+		return c.createFederatedGlobalRole(ctx, globalRole)
 	}
 	if err != nil {
 		klog.Error(err)
@@ -258,13 +259,13 @@ func (c *Controller) multiClusterSync(globalRole *iamv1alpha2.GlobalRole) error
 		federatedGlobalRole.Spec.Template.Annotations = globalRole.Annotations
 		federatedGlobalRole.Spec.Template.Labels = globalRole.Labels
 
-		return c.updateFederatedGlobalRole(&federatedGlobalRole)
+		return c.updateFederatedGlobalRole(ctx, &federatedGlobalRole)
 	}
 
 	return nil
 }
 
-func (c *Controller) createFederatedGlobalRole(globalRole *iamv1alpha2.GlobalRole) error {
+func (c *Controller) createFederatedGlobalRole(ctx context.Context, globalRole *iamv1alpha2.GlobalRole) error {
 	federatedGlobalRole := &iamv1alpha2.FederatedRole{
 		TypeMeta: metav1.TypeMeta{
 			Kind:       iamv1alpha2.FedGlobalRoleKind,
@@ -302,7 +303,7 @@ func (c *Controller) createFederatedGlobalRole(globalRole *iamv1alpha2.GlobalRol
 		AbsPath(fmt.Sprintf("/apis/%s/%s/%s", iamv1alpha2.FedGlobalRoleResource.Group,
 			iamv1alpha2.FedGlobalRoleResource.Version, iamv1alpha2.FedGlobalRoleResource.Name)).
 		Body(data).
-		Do().Error()
+		Do(ctx).Error()
 	if err != nil {
 		if errors.IsAlreadyExists(err) {
 			return nil
@@ -313,7 +314,7 @@ func (c *Controller) createFederatedGlobalRole(globalRole *iamv1alpha2.GlobalRol
 	return nil
 }
 
-func (c *Controller) updateFederatedGlobalRole(federatedGlobalRole *iamv1alpha2.FederatedRole) error {
+func (c *Controller) updateFederatedGlobalRole(ctx context.Context, federatedGlobalRole *iamv1alpha2.FederatedRole) error {
 
 	data, err := json.Marshal(federatedGlobalRole)
 	if err != nil {
@@ -327,7 +328,7 @@ func (c *Controller) updateFederatedGlobalRole(federatedGlobalRole *iamv1alpha2.
 			iamv1alpha2.FedGlobalRoleResource.Version, iamv1alpha2.FedGlobalRoleResource.Name,
 			federatedGlobalRole.Name)).
 		Body(data).
-		Do().Error()
+		Do(ctx).Error()
 	if err != nil {
 		if errors.IsNotFound(err) {
 			return nil
@@ -338,14 +339,14 @@ func (c *Controller) updateFederatedGlobalRole(federatedGlobalRole *iamv1alpha2.
 	return nil
 }
 
-func (c *Controller) ensureNotControlledByKubefed(globalRole *iamv1alpha2.GlobalRole) error {
+func (c *Controller) ensureNotControlledByKubefed(ctx context.Context, globalRole *iamv1alpha2.GlobalRole) error {
 	if globalRole.Labels[constants.KubefedManagedLabel] != "false" {
 		if globalRole.Labels == nil {
 			globalRole.Labels = make(map[string]string, 0)
 		}
 		globalRole = globalRole.DeepCopy()
 		globalRole.Labels[constants.KubefedManagedLabel] = "false"
-		_, err := c.ksClient.IamV1alpha2().GlobalRoles().Update(globalRole)
+		_, err := c.ksClient.IamV1alpha2().GlobalRoles().Update(ctx, globalRole, metav1.UpdateOptions{})
 		if err != nil {
 			klog.Error(err)
 		}

pkg/controller/globalrolebinding/globalrolebinding_controller.go

@@ -17,6 +17,7 @@ limitations under the License.
 package globalrolebinding
 
 import (
+	"context"
 	"encoding/json"
 	"fmt"
 	corev1 "k8s.io/api/core/v1"
@@ -314,7 +315,7 @@ func (c *Controller) assignClusterAdminRole(globalRoleBinding *iamv1alpha2.Globa
 		return err
 	}
 
-	_, err = c.k8sClient.RbacV1().ClusterRoleBindings().Create(clusterRoleBinding)
+	_, err = c.k8sClient.RbacV1().ClusterRoleBindings().Create(context.Background(), clusterRoleBinding, metav1.CreateOptions{})
 	if err != nil {
 		if errors.IsAlreadyExists(err) {
 			return nil
@@ -373,7 +374,7 @@ func (c *Controller) createFederatedGlobalRoleBinding(globalRoleBinding *iamv1al
 		AbsPath(fmt.Sprintf("/apis/%s/%s/%s", iamv1alpha2.FedGlobalRoleBindingResource.Group,
 			iamv1alpha2.FedGlobalRoleBindingResource.Version, iamv1alpha2.FedGlobalRoleBindingResource.Name)).
 		Body(data).
-		Do().Error()
+		Do(context.Background()).Error()
 	if err != nil {
 		if errors.IsAlreadyExists(err) {
 			return nil
@@ -398,7 +399,7 @@ func (c *Controller) updateFederatedGlobalRoleBinding(federatedGlobalRoleBinding
 			iamv1alpha2.FedGlobalRoleBindingResource.Version, iamv1alpha2.FedGlobalRoleBindingResource.Name,
 			federatedGlobalRoleBinding.Name)).
 		Body(data).
-		Do().Error()
+		Do(context.Background()).Error()
 	if err != nil {
 		if errors.IsNotFound(err) {
 			return nil
@@ -416,7 +417,7 @@ func (c *Controller) ensureNotControlledByKubefed(globalRoleBinding *iamv1alpha2
 		}
 		globalRoleBinding = globalRoleBinding.DeepCopy()
 		globalRoleBinding.Labels[constants.KubefedManagedLabel] = "false"
-		_, err := c.ksClient.IamV1alpha2().GlobalRoleBindings().Update(globalRoleBinding)
+		_, err := c.ksClient.IamV1alpha2().GlobalRoleBindings().Update(context.Background(), globalRoleBinding, metav1.UpdateOptions{})
 		if err != nil {
 			klog.Error(err)
 		}

pkg/controller/group/group_controller.go

@@ -17,6 +17,7 @@ limitations under the License.
 package group
 
 import (
+	"context"
 	"fmt"
 	"reflect"
 
@@ -143,7 +144,7 @@ func (c *Controller) reconcile(key string) error {
 		}
 
 		if g != nil {
-			if _, err = c.ksClient.IamV1alpha2().Groups().Update(g); err != nil {
+			if _, err = c.ksClient.IamV1alpha2().Groups().Update(context.Background(), g, metav1.UpdateOptions{}); err != nil {
 				return err
 			}
 			// Skip reconcile when group is updated.
@@ -166,7 +167,7 @@ func (c *Controller) reconcile(key string) error {
 				return item == finalizer
 			})
 
-			if group, err = c.ksClient.IamV1alpha2().Groups().Update(group); err != nil {
+			if group, err = c.ksClient.IamV1alpha2().Groups().Update(context.Background(), group, metav1.UpdateOptions{}); err != nil {
 				return err
 			}
 		}
@@ -191,10 +192,8 @@ func (c *Controller) deleteGroupBindings(group *iam1alpha2.Group) error {
 	listOptions := metav1.ListOptions{
 		LabelSelector: labels.SelectorFromSet(labels.Set{iam1alpha2.GroupReferenceLabel: group.Name}).String(),
 	}
-	deleteOptions := metav1.NewDeleteOptions(0)
-
 	if err := c.ksClient.IamV1alpha2().GroupBindings().
-		DeleteCollection(deleteOptions, listOptions); err != nil {
+		DeleteCollection(context.Background(), *metav1.NewDeleteOptions(0), listOptions); err != nil {
 		klog.Error(err)
 		return err
 	}
@@ -206,26 +205,26 @@ func (c *Controller) deleteRoleBindings(group *iam1alpha2.Group) error {
 	listOptions := metav1.ListOptions{
 		LabelSelector: labels.SelectorFromSet(labels.Set{iam1alpha2.GroupReferenceLabel: group.Name}).String(),
 	}
-	deleteOptions := metav1.NewDeleteOptions(0)
+	deleteOptions := *metav1.NewDeleteOptions(0)
 
 	if err := c.ksClient.IamV1alpha2().WorkspaceRoleBindings().
-		DeleteCollection(deleteOptions, listOptions); err != nil {
+		DeleteCollection(context.Background(), deleteOptions, listOptions); err != nil {
 		klog.Error(err)
 		return err
 	}
 
 	if err := c.k8sClient.RbacV1().ClusterRoleBindings().
-		DeleteCollection(deleteOptions, listOptions); err != nil {
+		DeleteCollection(context.Background(), deleteOptions, listOptions); err != nil {
 		klog.Error(err)
 		return err
 	}
 
-	if result, err := c.k8sClient.CoreV1().Namespaces().List(metav1.ListOptions{}); err != nil {
+	if result, err := c.k8sClient.CoreV1().Namespaces().List(context.Background(), metav1.ListOptions{}); err != nil {
 		klog.Error(err)
 		return err
 	} else {
 		for _, namespace := range result.Items {
-			if err = c.k8sClient.RbacV1().RoleBindings(namespace.Name).DeleteCollection(deleteOptions, listOptions); err != nil {
+			if err = c.k8sClient.RbacV1().RoleBindings(namespace.Name).DeleteCollection(context.Background(), deleteOptions, listOptions); err != nil {
 				klog.Error(err)
 				return err
 			}
@@ -250,7 +249,7 @@ func (c *Controller) multiClusterSync(group *iam1alpha2.Group) error {
 
 		obj.Spec.Template.Labels = group.Labels
 
-		if _, err = c.ksClient.TypesV1beta1().FederatedGroups().Update(obj); err != nil {
+		if _, err = c.ksClient.TypesV1beta1().FederatedGroups().Update(context.Background(), obj, metav1.UpdateOptions{}); err != nil {
 			return err
 		}
 	}
@@ -280,7 +279,7 @@ func (c *Controller) createFederatedGroup(group *iam1alpha2.Group) error {
 	if err != nil {
 		return err
 	}
-	if _, err = c.ksClient.TypesV1beta1().FederatedGroups().Create(federatedGroup); err != nil {
+	if _, err = c.ksClient.TypesV1beta1().FederatedGroups().Create(context.Background(), federatedGroup, metav1.CreateOptions{}); err != nil {
 		return err
 	}
 	return nil

pkg/controller/groupbinding/groupbinding_controller.go

@@ -17,6 +17,7 @@ limitations under the License.
 package groupbinding
 
 import (
+	"context"
 	"fmt"
 
 	"reflect"
@@ -134,7 +135,7 @@ func (c *Controller) reconcile(key string) error {
 			}
 		}
 		if g != nil {
-			if groupBinding, err = c.ksClient.IamV1alpha2().GroupBindings().Update(g); err != nil {
+			if groupBinding, err = c.ksClient.IamV1alpha2().GroupBindings().Update(context.Background(), g, metav1.UpdateOptions{}); err != nil {
 				return err
 			}
 			// Skip reconcile when group is updated.
@@ -153,7 +154,7 @@ func (c *Controller) reconcile(key string) error {
 				return item == finalizer
 			})
 
-			if groupBinding, err = c.ksClient.IamV1alpha2().GroupBindings().Update(groupBinding); err != nil {
+			if groupBinding, err = c.ksClient.IamV1alpha2().GroupBindings().Update(context.Background(), groupBinding, metav1.UpdateOptions{}); err != nil {
 				return err
 			}
 		}
@@ -210,7 +211,7 @@ func (c *Controller) updateUserGroups(groupBinding *iamv1alpha2.GroupBinding, op
 
 	for _, u := range groupBinding.Users {
 		// Ignore the user if the user if being deleted.
-		if user, err := c.ksClient.IamV1alpha2().Users().Get(u, metav1.GetOptions{}); err == nil && user.ObjectMeta.DeletionTimestamp.IsZero() {
+		if user, err := c.ksClient.IamV1alpha2().Users().Get(context.Background(), u, metav1.GetOptions{}); err == nil && user.ObjectMeta.DeletionTimestamp.IsZero() {
 
 			if errors.IsNotFound(err) {
 				klog.Infof("user %s doesn't exist any more", u)
@@ -239,7 +240,7 @@ func (c *Controller) patchUser(user *iamv1alpha2.User, groups []string) error {
 	patch := client.MergeFrom(user)
 	patchData, _ := patch.Data(newUser)
 	if _, err := c.ksClient.IamV1alpha2().Users().
-		Patch(user.Name, patch.Type(), patchData); err != nil {
+		Patch(context.Background(), user.Name, patch.Type(), patchData, metav1.PatchOptions{}); err != nil {
 		return err
 	}
 	return nil
@@ -265,7 +266,7 @@ func (c *Controller) multiClusterSync(groupBinding *iamv1alpha2.GroupBinding) er
 		fedGroupBinding.Spec.Template.Users = groupBinding.Users
 		fedGroupBinding.Spec.Template.Labels = groupBinding.Labels
 
-		if _, err = c.ksClient.TypesV1beta1().FederatedGroupBindings().Update(fedGroupBinding); err != nil {
+		if _, err = c.ksClient.TypesV1beta1().FederatedGroupBindings().Update(context.Background(), fedGroupBinding, metav1.UpdateOptions{}); err != nil {
 			return err
 		}
 	}
@@ -301,7 +302,7 @@ func (c *Controller) createFederatedGroupBinding(groupBinding *iamv1alpha2.Group
 	if err != nil {
 		return err
 	}
-	if _, err = c.ksClient.TypesV1beta1().FederatedGroupBindings().Create(federatedGroup); err != nil {
+	if _, err = c.ksClient.TypesV1beta1().FederatedGroupBindings().Create(context.Background(), federatedGroup, metav1.CreateOptions{}); err != nil {
 		return err
 	}
 	return nil

pkg/controller/job/job_controller.go

@@ -17,8 +17,10 @@ limitations under the License.
 package job
 
 import (
+	"context"
 	"encoding/json"
 	"fmt"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"reflect"
 
 	batchv1 "k8s.io/api/batch/v1"
@@ -234,7 +236,7 @@ func (v *JobController) makeRevision(job *batchv1.Job) error {
 	}
 
 	job.Annotations[revisionsAnnotationKey] = string(revisionsByte)
-	_, err = v.client.BatchV1().Jobs(job.Namespace).Update(job)
+	_, err = v.client.BatchV1().Jobs(job.Namespace).Update(context.Background(), job, metav1.UpdateOptions{})
 
 	if err != nil {
 		return err

pkg/controller/loginrecord/loginrecord_controller.go

@@ -17,6 +17,7 @@ limitations under the License.
 package loginrecord
 
 import (
+	"context"
 	"fmt"
 	corev1 "k8s.io/api/core/v1"
 	"k8s.io/apimachinery/pkg/api/errors"
@@ -123,7 +124,7 @@ func (c *loginRecordController) reconcile(key string) error {
 	now := time.Now()
 	// login record beyonds retention period
 	if loginRecord.CreationTimestamp.Add(c.loginHistoryRetentionPeriod).Before(now) {
-		if err = c.ksClient.IamV1alpha2().LoginRecords().Delete(loginRecord.Name, metav1.NewDeleteOptions(0)); err != nil {
+		if err = c.ksClient.IamV1alpha2().LoginRecords().Delete(context.Background(), loginRecord.Name, *metav1.NewDeleteOptions(0)); err != nil {
 			klog.Error(err)
 			return err
 		}
@@ -155,7 +156,7 @@ func (c *loginRecordController) updateUserLastLoginTime(loginRecord *iamv1alpha2
 	if user.DeletionTimestamp.IsZero() &&
 		(user.Status.LastLoginTime == nil || user.Status.LastLoginTime.Before(&loginRecord.CreationTimestamp)) {
 		user.Status.LastLoginTime = &loginRecord.CreationTimestamp
-		user, err = c.ksClient.IamV1alpha2().Users().UpdateStatus(user)
+		user, err = c.ksClient.IamV1alpha2().Users().UpdateStatus(context.Background(), user, metav1.UpdateOptions{})
 		return err
 	}
 	return nil

pkg/controller/loginrecord/loginrecord_controller_test.go

@@ -147,7 +147,7 @@ func (f *fixture) runController(user string, startInformers bool, expectError bo
 	actions := filterInformerActions(f.ksclient.Actions())
 	for j, action := range actions {
 		if len(f.actions) < j+1 {
-			f.t.Errorf("%d unexpected actions: %+v", len(actions)-len(f.actions), actions[j:])
+			f.t.Errorf("%d unexpected actions: %+v", len(actions)-len(f.actions), actions)
 			break
 		}
 

pkg/controller/network/nsnetworkpolicy/nsnetworkpolicy_controller.go

@@ -17,6 +17,7 @@ limitations under the License.
 package nsnetworkpolicy
 
 import (
+	"context"
 	"fmt"
 	"net"
 	"sort"
@@ -27,7 +28,6 @@ import (
 	netv1 "k8s.io/api/networking/v1"
 	"k8s.io/apimachinery/pkg/api/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	typev1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/labels"
 	"k8s.io/apimachinery/pkg/util/intstr"
 	uruntime "k8s.io/apimachinery/pkg/util/runtime"
@@ -467,7 +467,7 @@ func (c *NSNetworkPolicyController) syncNs(key string) error {
 	if delete || matchWorkspace {
 		//delete all namespace np when networkisolate not active
 		if err == nil && len(nsnpList) > 0 {
-			if c.ksclient.NamespaceNetworkPolicies(ns.Name).DeleteCollection(nil, typev1.ListOptions{}) != nil {
+			if c.ksclient.NamespaceNetworkPolicies(ns.Name).DeleteCollection(context.Background(), metav1.DeleteOptions{}, metav1.ListOptions{}) != nil {
 				klog.Errorf("Error when delete all nsnps in namespace %s", ns.Name)
 			}
 		}

pkg/controller/network/nsnetworkpolicy/provider/ns_k8s.go

@@ -145,7 +145,7 @@ func (c *k8sPolicyController) syncToDatastore(key string) error {
 		// The object no longer exists - delete from the datastore.
 		klog.Infof("Deleting NetworkPolicy %s from k8s datastore", key)
 		ns, name := getkey(key)
-		err := c.client.NetworkingV1().NetworkPolicies(ns).Delete(name, nil)
+		err := c.client.NetworkingV1().NetworkPolicies(ns).Delete(context.Background(), name, metav1.DeleteOptions{})
 		if errors.IsNotFound(err) {
 			return nil
 		}
@@ -164,7 +164,7 @@ func (c *k8sPolicyController) syncToDatastore(key string) error {
 			}
 
 			// Doesn't exist - create it.
-			_, err := c.client.NetworkingV1().NetworkPolicies(p.Namespace).Create(&p)
+			_, err := c.client.NetworkingV1().NetworkPolicies(p.Namespace).Create(context.Background(), &p, metav1.CreateOptions{})
 			if err != nil {
 				klog.Warningf("Failed to create NetworkPolicy %s", key)
 				return err
@@ -178,7 +178,7 @@ func (c *k8sPolicyController) syncToDatastore(key string) error {
 
 		// The policy already exists, update it and write it back to the datastore.
 		gp.Spec = p.Spec
-		_, err = c.client.NetworkingV1().NetworkPolicies(p.Namespace).Update(gp)
+		_, err = c.client.NetworkingV1().NetworkPolicies(p.Namespace).Update(context.Background(), gp, metav1.UpdateOptions{})
 		if err != nil {
 			klog.Warningf("Failed to update NetworkPolicy %s", key)
 			return err

pkg/controller/pipeline/pipeline_controller.go

@@ -17,10 +17,12 @@ limitations under the License.
 package pipeline
 
 import (
+	"context"
 	"fmt"
 	"github.com/emicklei/go-restful"
 	v1 "k8s.io/api/core/v1"
 	"k8s.io/apimachinery/pkg/api/errors"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	utilruntime "k8s.io/apimachinery/pkg/util/runtime"
 	"k8s.io/apimachinery/pkg/util/wait"
 	corev1informer "k8s.io/client-go/informers/core/v1"
@@ -295,7 +297,7 @@ func (c *Controller) syncHandler(key string) error {
 	}
 
 	if !reflect.DeepEqual(pipeline, copyPipeline) {
-		_, err = c.kubesphereClient.DevopsV1alpha3().Pipelines(nsName).Update(copyPipeline)
+		_, err = c.kubesphereClient.DevopsV1alpha3().Pipelines(nsName).Update(context.Background(), copyPipeline, metav1.UpdateOptions{})
 		if err != nil {
 			klog.V(8).Info(err, fmt.Sprintf("failed to update pipeline %s ", key))
 			return err

pkg/controller/s2ibinary/s2ibinary_controller.go

@@ -17,9 +17,11 @@ limitations under the License.
 package s2ibinary
 
 import (
+	"context"
 	"fmt"
 	v1 "k8s.io/api/core/v1"
 	"k8s.io/apimachinery/pkg/api/errors"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	utilruntime "k8s.io/apimachinery/pkg/util/runtime"
 	"k8s.io/apimachinery/pkg/util/wait"
 	clientset "k8s.io/client-go/kubernetes"
@@ -198,7 +200,7 @@ func (c *Controller) syncHandler(key string) error {
 	if s2ibin.ObjectMeta.DeletionTimestamp.IsZero() {
 		if !sliceutil.HasString(s2ibin.ObjectMeta.Finalizers, devopsv1alpha1.S2iBinaryFinalizerName) {
 			s2ibin.ObjectMeta.Finalizers = append(s2ibin.ObjectMeta.Finalizers, devopsv1alpha1.S2iBinaryFinalizerName)
-			_, err := c.devopsClient.DevopsV1alpha1().S2iBinaries(namespace).Update(s2ibin)
+			_, err := c.devopsClient.DevopsV1alpha1().S2iBinaries(namespace).Update(context.Background(), s2ibin, metav1.UpdateOptions{})
 			if err != nil {
 				klog.Error(err, fmt.Sprintf("failed to update s2ibin %s ", key))
 				return err
@@ -214,7 +216,7 @@ func (c *Controller) syncHandler(key string) error {
 			s2ibin.ObjectMeta.Finalizers = sliceutil.RemoveString(s2ibin.ObjectMeta.Finalizers, func(item string) bool {
 				return item == devopsv1alpha1.S2iBinaryFinalizerName
 			})
-			_, err := c.devopsClient.DevopsV1alpha1().S2iBinaries(namespace).Update(s2ibin)
+			_, err := c.devopsClient.DevopsV1alpha1().S2iBinaries(namespace).Update(context.Background(), s2ibin, metav1.UpdateOptions{})
 			if err != nil {
 				klog.Error(err, fmt.Sprintf("failed to update s2ibin %s ", key))
 				return err

pkg/controller/s2irun/s2irun_controller.go

@@ -17,6 +17,7 @@ limitations under the License.
 package s2irun
 
 import (
+	"context"
 	"fmt"
 	v1 "k8s.io/api/core/v1"
 	"k8s.io/apimachinery/pkg/api/errors"
@@ -205,7 +206,7 @@ func (c Controller) syncHandler(key string) error {
 			if s2irun.ObjectMeta.DeletionTimestamp.IsZero() {
 				if !sliceutil.HasString(s2irun.ObjectMeta.Finalizers, devopsv1alpha1.S2iBinaryFinalizerName) {
 					s2irun.ObjectMeta.Finalizers = append(s2irun.ObjectMeta.Finalizers, devopsv1alpha1.S2iBinaryFinalizerName)
-					_, err = c.devopsClient.DevopsV1alpha1().S2iRuns(namespace).Update(s2irun)
+					_, err = c.devopsClient.DevopsV1alpha1().S2iRuns(namespace).Update(context.Background(), s2irun, metav1.UpdateOptions{})
 					if err != nil {
 						klog.Error(err, fmt.Sprintf("failed to update s2irun %s", key))
 						return err
@@ -221,7 +222,7 @@ func (c Controller) syncHandler(key string) error {
 					s2irun.ObjectMeta.Finalizers = sliceutil.RemoveString(s2irun.ObjectMeta.Finalizers, func(item string) bool {
 						return item == devopsv1alpha1.S2iBinaryFinalizerName
 					})
-					_, err = c.devopsClient.DevopsV1alpha1().S2iRuns(namespace).Update(s2irun)
+					_, err = c.devopsClient.DevopsV1alpha1().S2iRuns(namespace).Update(context.Background(), s2irun, metav1.UpdateOptions{})
 					if err != nil {
 						klog.Error(err, fmt.Sprintf("failed to update s2irun %s ", key))
 						return err
@@ -250,7 +251,7 @@ func (c Controller) DeleteS2iBinary(s2irun *devopsv1alpha1.S2iRun) error {
 		klog.Error(err, fmt.Sprintf("failed to get s2ibin %s/%s ", s2irun.Namespace, s2iBinName))
 		return err
 	}
-	err = c.devopsClient.DevopsV1alpha1().S2iBinaries(s2iBin.Namespace).Delete(s2iBinName, nil)
+	err = c.devopsClient.DevopsV1alpha1().S2iBinaries(s2iBin.Namespace).Delete(context.Background(), s2iBinName, metav1.DeleteOptions{})
 	if err != nil {
 		if errors.IsNotFound(err) {
 			klog.Info(fmt.Sprintf("s2ibin '%s/%s' has been delted ", s2irun.Namespace, s2iBinName))
@@ -284,7 +285,7 @@ func (c Controller) cleanOtherS2iBinary(namespace string) error {
 				return err
 			}
 			if len(runs) == 0 {
-				err = c.devopsClient.DevopsV1alpha1().S2iBinaries(namespace).Delete(s2iBin.Name, nil)
+				err = c.devopsClient.DevopsV1alpha1().S2iBinaries(namespace).Delete(context.Background(), s2iBin.Name, metav1.DeleteOptions{})
 				if err != nil {
 					if errors.IsNotFound(err) {
 						klog.Info(fmt.Sprintf("s2ibin '%s/%s' has been deleted ", namespace, s2iBin.Name))

pkg/controller/storage/capability/capability_controller.go

@@ -19,6 +19,7 @@
 package capability
 
 import (
+	"context"
 	"fmt"
 	"k8s.io/apimachinery/pkg/labels"
 	"k8s.io/apimachinery/pkg/util/version"
@@ -28,10 +29,10 @@ import (
 	"strings"
 	"time"
 
-	snapshotv1beta1 "github.com/kubernetes-csi/external-snapshotter/v2/pkg/apis/volumesnapshot/v1beta1"
-	snapshotclient "github.com/kubernetes-csi/external-snapshotter/v2/pkg/client/clientset/versioned/typed/volumesnapshot/v1beta1"
-	snapinformers "github.com/kubernetes-csi/external-snapshotter/v2/pkg/client/informers/externalversions/volumesnapshot/v1beta1"
-	snapshotlisters "github.com/kubernetes-csi/external-snapshotter/v2/pkg/client/listers/volumesnapshot/v1beta1"
+	snapshotv1beta1 "github.com/kubernetes-csi/external-snapshotter/client/v3/apis/volumesnapshot/v1beta1"
+	snapshotclient "github.com/kubernetes-csi/external-snapshotter/client/v3/clientset/versioned/typed/volumesnapshot/v1beta1"
+	snapinformers "github.com/kubernetes-csi/external-snapshotter/client/v3/informers/externalversions/volumesnapshot/v1beta1"
+	snapshotlisters "github.com/kubernetes-csi/external-snapshotter/client/v3/listers/volumesnapshot/v1beta1"
 	storagev1 "k8s.io/api/storage/v1"
 	storagev1beta1 "k8s.io/api/storage/v1beta1"
 	"k8s.io/apimachinery/pkg/api/errors"
@@ -298,7 +299,7 @@ func (c *StorageCapabilityController) syncHandler(key string) error {
 					Driver:         storageClass.Provisioner,
 					DeletionPolicy: snapshotv1beta1.VolumeSnapshotContentDelete,
 				}
-				_, err = c.snapshotClassClient.Create(volumeSnapshotClassCreate)
+				_, err = c.snapshotClassClient.Create(context.Background(), volumeSnapshotClassCreate, metav1.CreateOptions{})
 				if err != nil {
 					return err
 				}
@@ -319,7 +320,7 @@ func (c *StorageCapabilityController) syncHandler(key string) error {
 			storageClassCapabilityCreate := &capability.StorageClassCapability{ObjectMeta: metav1.ObjectMeta{Name: storageClass.Name}}
 			storageClassCapabilityCreate.Spec = *capabilitySpec
 			klog.Info("Create StorageClassCapability: ", storageClassCapabilityCreate)
-			_, err = c.storageClassCapabilityClient.Create(storageClassCapabilityCreate)
+			_, err = c.storageClassCapabilityClient.Create(context.Background(), storageClassCapabilityCreate, metav1.CreateOptions{})
 			return err
 		}
 		return err
@@ -329,7 +330,7 @@ func (c *StorageCapabilityController) syncHandler(key string) error {
 	storageClassCapabilityUpdate.Spec = *capabilitySpec
 	if !reflect.DeepEqual(storageClassCapabilityExist, storageClassCapabilityUpdate) {
 		klog.Info("Update StorageClassCapability: ", storageClassCapabilityUpdate)
-		_, err = c.storageClassCapabilityClient.Update(storageClassCapabilityUpdate)
+		_, err = c.storageClassCapabilityClient.Update(context.Background(), storageClassCapabilityUpdate, metav1.UpdateOptions{})
 		return err
 	}
 	return nil
@@ -343,7 +344,7 @@ func (c *StorageCapabilityController) updateStorageClassSnapshotSupported(storag
 	// err != nil means annotationSupportSnapshot is not illegal, include empty
 	if err != nil || snapshotSupported != snapshotSupportedAnnotated {
 		storageClass.Annotations[annotationSupportSnapshot] = strconv.FormatBool(snapshotSupported)
-		_, err = c.storageClassClient.Update(storageClass)
+		_, err = c.storageClassClient.Update(context.Background(), storageClass, metav1.UpdateOptions{})
 		if err != nil {
 			return err
 		}
@@ -360,7 +361,7 @@ func (c *StorageCapabilityController) deleteStorageCapability(name string) error
 		return err
 	}
 	klog.Infof("Delete StorageClassCapability %s", name)
-	return c.storageClassCapabilityClient.Delete(name, &metav1.DeleteOptions{})
+	return c.storageClassCapabilityClient.Delete(context.Background(), name, metav1.DeleteOptions{})
 }
 
 func (c *StorageCapabilityController) deleteSnapshotClass(name string) error {
@@ -375,7 +376,7 @@ func (c *StorageCapabilityController) deleteSnapshotClass(name string) error {
 		return err
 	}
 	klog.Infof("Delete SnapshotClass %s", name)
-	return c.snapshotClassClient.Delete(name, &metav1.DeleteOptions{})
+	return c.snapshotClassClient.Delete(context.Background(), name, metav1.DeleteOptions{})
 }
 
 func (c *StorageCapabilityController) capabilityFromProvisioner(provisioner string) (*capability.StorageClassCapabilitySpec, error) {

pkg/controller/storage/capability/capability_controller_test.go

@@ -23,9 +23,9 @@ import (
 	"math/rand"
 
 	//"github.com/google/go-cmp/cmp"
-	snapbeta1 "github.com/kubernetes-csi/external-snapshotter/v2/pkg/apis/volumesnapshot/v1beta1"
-	snapfake "github.com/kubernetes-csi/external-snapshotter/v2/pkg/client/clientset/versioned/fake"
-	snapinformers "github.com/kubernetes-csi/external-snapshotter/v2/pkg/client/informers/externalversions"
+	snapbeta1 "github.com/kubernetes-csi/external-snapshotter/client/v3/apis/volumesnapshot/v1beta1"
+	snapfake "github.com/kubernetes-csi/external-snapshotter/client/v3/clientset/versioned/fake"
+	snapinformers "github.com/kubernetes-csi/external-snapshotter/client/v3/informers/externalversions"
 	storagev1 "k8s.io/api/storage/v1"
 	storagev1beta1 "k8s.io/api/storage/v1beta1"
 	"k8s.io/apimachinery/pkg/apis/meta/v1"

pkg/controller/storage/expansion/expansion_controller.go

@@ -19,6 +19,7 @@
 package expansion
 
 import (
+	"context"
 	"errors"
 	"fmt"
 	appsv1 "k8s.io/api/apps/v1"
@@ -434,7 +435,7 @@ func (c *VolumeExpansionController) scaleDown(workload interface{}, namespace st
 				Replicas: 0,
 			},
 		}
-		_, err := c.kubeclientset.AppsV1().Deployments(namespace).UpdateScale(deploy.GetName(), scale)
+		_, err := c.kubeclientset.AppsV1().Deployments(namespace).UpdateScale(context.Background(), deploy.GetName(), scale, metav1.UpdateOptions{})
 		return err
 	case *appsv1.StatefulSet:
 		sts := workload.(*appsv1.StatefulSet)
@@ -447,7 +448,7 @@ func (c *VolumeExpansionController) scaleDown(workload interface{}, namespace st
 				Replicas: 0,
 			},
 		}
-		_, err := c.kubeclientset.AppsV1().StatefulSets(namespace).UpdateScale(sts.GetName(), scale)
+		_, err := c.kubeclientset.AppsV1().StatefulSets(namespace).UpdateScale(context.Background(), sts.GetName(), scale, metav1.UpdateOptions{})
 		return err
 	default:
 		return fmt.Errorf("unsupported type %T", workload)
@@ -467,7 +468,7 @@ func (c *VolumeExpansionController) scaleUp(workload interface{}, namespace stri
 				Replicas: *deploy.Spec.Replicas,
 			},
 		}
-		_, err := c.kubeclientset.AppsV1().Deployments(namespace).UpdateScale(deploy.GetName(), scale)
+		_, err := c.kubeclientset.AppsV1().Deployments(namespace).UpdateScale(context.Background(), deploy.GetName(), scale, metav1.UpdateOptions{})
 		return err
 	case *appsv1.StatefulSet:
 		sts := workload.(*appsv1.StatefulSet)
@@ -480,7 +481,7 @@ func (c *VolumeExpansionController) scaleUp(workload interface{}, namespace stri
 				Replicas: *sts.Spec.Replicas,
 			},
 		}
-		_, err := c.kubeclientset.AppsV1().StatefulSets(namespace).UpdateScale(sts.GetName(), scale)
+		_, err := c.kubeclientset.AppsV1().StatefulSets(namespace).UpdateScale(context.Background(), sts.GetName(), scale, metav1.UpdateOptions{})
 		return err
 	default:
 		return fmt.Errorf("unsupported type %T", workload)

pkg/controller/user/user_controller.go

@@ -17,6 +17,7 @@ limitations under the License.
 package user
 
 import (
+	"context"
 	"encoding/json"
 	"fmt"
 	"kubesphere.io/kubesphere/pkg/controller/utils/controller"
@@ -163,7 +164,7 @@ func (c *userController) reconcile(key string) error {
 		if !sliceutil.HasString(user.Finalizers, finalizer) {
 			user.ObjectMeta.Finalizers = append(user.ObjectMeta.Finalizers, finalizer)
 
-			if user, err = c.ksClient.IamV1alpha2().Users().Update(user); err != nil {
+			if user, err = c.ksClient.IamV1alpha2().Users().Update(context.Background(), user, metav1.UpdateOptions{}); err != nil {
 				return err
 			}
 		}
@@ -208,7 +209,7 @@ func (c *userController) reconcile(key string) error {
 				return item == finalizer
 			})
 
-			if user, err = c.ksClient.IamV1alpha2().Users().Update(user); err != nil {
+			if user, err = c.ksClient.IamV1alpha2().Users().Update(context.Background(), user, metav1.UpdateOptions{}); err != nil {
 				return err
 			}
 		}
@@ -279,7 +280,7 @@ func (c *userController) encryptPassword(user *iamv1alpha2.User) (*iamv1alpha2.U
 		}
 		// ensure plain text password won't be kept anywhere
 		delete(user.Annotations, corev1.LastAppliedConfigAnnotation)
-		return c.ksClient.IamV1alpha2().Users().Update(user)
+		return c.ksClient.IamV1alpha2().Users().Update(context.Background(), user, metav1.UpdateOptions{})
 	}
 	return user, nil
 }
@@ -291,7 +292,7 @@ func (c *userController) ensureNotControlledByKubefed(user *iamv1alpha2.User) er
 		}
 		user = user.DeepCopy()
 		user.Labels[constants.KubefedManagedLabel] = "false"
-		_, err := c.ksClient.IamV1alpha2().Users().Update(user)
+		_, err := c.ksClient.IamV1alpha2().Users().Update(context.Background(), user, metav1.UpdateOptions{})
 		if err != nil {
 			klog.Error(err)
 		}
@@ -369,7 +370,7 @@ func (c *userController) createFederatedUser(user *iamv1alpha2.User) error {
 		AbsPath(fmt.Sprintf("/apis/%s/%s/%s", iamv1alpha2.FedUserResource.Group,
 			iamv1alpha2.FedUserResource.Version, iamv1alpha2.FedUserResource.Name)).
 		Body(data).
-		Do().Error()
+		Do(context.Background()).Error()
 	if err != nil {
 		if errors.IsAlreadyExists(err) {
 			return nil
@@ -391,7 +392,7 @@ func (c *userController) updateFederatedUser(fedUser *iamv1alpha2.FederatedUser)
 		AbsPath(fmt.Sprintf("/apis/%s/%s/%s/%s", iamv1alpha2.FedUserResource.Group,
 			iamv1alpha2.FedUserResource.Version, iamv1alpha2.FedUserResource.Name, fedUser.Name)).
 		Body(data).
-		Do().Error()
+		Do(context.Background()).Error()
 	if err != nil {
 		if errors.IsNotFound(err) {
 			return nil
@@ -441,9 +442,8 @@ func (c *userController) deleteGroupBindings(user *iamv1alpha2.User) error {
 	listOptions := metav1.ListOptions{
 		LabelSelector: labels.SelectorFromSet(labels.Set{iamv1alpha2.UserReferenceLabel: user.Name}).String(),
 	}
-	deleteOptions := metav1.NewDeleteOptions(0)
 	if err := c.ksClient.IamV1alpha2().GroupBindings().
-		DeleteCollection(deleteOptions, listOptions); err != nil {
+		DeleteCollection(context.Background(), *metav1.NewDeleteOptions(0), listOptions); err != nil {
 		klog.Error(err)
 		return err
 	}
@@ -454,31 +454,31 @@ func (c *userController) deleteRoleBindings(user *iamv1alpha2.User) error {
 	listOptions := metav1.ListOptions{
 		LabelSelector: labels.SelectorFromSet(labels.Set{iamv1alpha2.UserReferenceLabel: user.Name}).String(),
 	}
-	deleteOptions := metav1.NewDeleteOptions(0)
+	deleteOptions := *metav1.NewDeleteOptions(0)
 	if err := c.ksClient.IamV1alpha2().GlobalRoleBindings().
-		DeleteCollection(deleteOptions, listOptions); err != nil {
+		DeleteCollection(context.Background(), deleteOptions, listOptions); err != nil {
 		klog.Error(err)
 		return err
 	}
 
 	if err := c.ksClient.IamV1alpha2().WorkspaceRoleBindings().
-		DeleteCollection(deleteOptions, listOptions); err != nil {
+		DeleteCollection(context.Background(), deleteOptions, listOptions); err != nil {
 		klog.Error(err)
 		return err
 	}
 
 	if err := c.k8sClient.RbacV1().ClusterRoleBindings().
-		DeleteCollection(deleteOptions, listOptions); err != nil {
+		DeleteCollection(context.Background(), deleteOptions, listOptions); err != nil {
 		klog.Error(err)
 		return err
 	}
 
-	if result, err := c.k8sClient.CoreV1().Namespaces().List(metav1.ListOptions{}); err != nil {
+	if result, err := c.k8sClient.CoreV1().Namespaces().List(context.Background(), metav1.ListOptions{}); err != nil {
 		klog.Error(err)
 		return err
 	} else {
 		for _, namespace := range result.Items {
-			if err = c.k8sClient.RbacV1().RoleBindings(namespace.Name).DeleteCollection(deleteOptions, listOptions); err != nil {
+			if err = c.k8sClient.RbacV1().RoleBindings(namespace.Name).DeleteCollection(context.Background(), deleteOptions, listOptions); err != nil {
 				klog.Error(err)
 				return err
 			}
@@ -492,10 +492,8 @@ func (c *userController) deleteLoginRecords(user *iamv1alpha2.User) error {
 	listOptions := metav1.ListOptions{
 		LabelSelector: labels.SelectorFromSet(labels.Set{iamv1alpha2.UserReferenceLabel: user.Name}).String(),
 	}
-	deleteOptions := metav1.NewDeleteOptions(0)
-
 	if err := c.ksClient.IamV1alpha2().LoginRecords().
-		DeleteCollection(deleteOptions, listOptions); err != nil {
+		DeleteCollection(context.Background(), *metav1.NewDeleteOptions(0), listOptions); err != nil {
 		klog.Error(err)
 		return err
 	}
@@ -519,7 +517,7 @@ func (c *userController) syncUserStatus(user *iamv1alpha2.User) (*iamv1alpha2.Us
 			State:              &active,
 			LastTransitionTime: &metav1.Time{Time: time.Now()},
 		}
-		return c.ksClient.IamV1alpha2().Users().UpdateStatus(expected)
+		return c.ksClient.IamV1alpha2().Users().UpdateStatus(context.Background(), expected, metav1.UpdateOptions{})
 	}
 
 	// becomes inactive after setting a blank password
@@ -530,7 +528,7 @@ func (c *userController) syncUserStatus(user *iamv1alpha2.User) (*iamv1alpha2.Us
 			State:              nil,
 			LastTransitionTime: &metav1.Time{Time: time.Now()},
 		}
-		return c.ksClient.IamV1alpha2().Users().UpdateStatus(expected)
+		return c.ksClient.IamV1alpha2().Users().UpdateStatus(context.Background(), expected, metav1.UpdateOptions{})
 	}
 
 	// becomes active after password encrypted
@@ -542,7 +540,7 @@ func (c *userController) syncUserStatus(user *iamv1alpha2.User) (*iamv1alpha2.Us
 			State:              &active,
 			LastTransitionTime: &metav1.Time{Time: time.Now()},
 		}
-		return c.ksClient.IamV1alpha2().Users().UpdateStatus(expected)
+		return c.ksClient.IamV1alpha2().Users().UpdateStatus(context.Background(), expected, metav1.UpdateOptions{})
 	}
 
 	// blocked user, check if need to unblock user
@@ -556,7 +554,7 @@ func (c *userController) syncUserStatus(user *iamv1alpha2.User) (*iamv1alpha2.Us
 				State:              &active,
 				LastTransitionTime: &metav1.Time{Time: time.Now()},
 			}
-			return c.ksClient.IamV1alpha2().Users().UpdateStatus(expected)
+			return c.ksClient.IamV1alpha2().Users().UpdateStatus(context.Background(), expected, metav1.UpdateOptions{})
 		}
 	}
 
@@ -588,7 +586,7 @@ func (c *userController) syncUserStatus(user *iamv1alpha2.User) (*iamv1alpha2.Us
 		}
 		// block user for AuthenticateRateLimiterDuration duration, after that put it back to the queue to unblock
 		c.Workqueue.AddAfter(user.Name, c.authenticationOptions.AuthenticateRateLimiterDuration)
-		return c.ksClient.IamV1alpha2().Users().UpdateStatus(expect)
+		return c.ksClient.IamV1alpha2().Users().UpdateStatus(context.Background(), expect, metav1.UpdateOptions{})
 	}
 
 	return user, nil

pkg/controller/virtualservice/virtualservice_controller.go

@@ -17,6 +17,7 @@ limitations under the License.
 package virtualservice
 
 import (
+	"context"
 	"fmt"
 	"reflect"
 	"strings"
@@ -236,14 +237,14 @@ func (v *VirtualServiceController) syncService(key string) error {
 	if err != nil {
 		if errors.IsNotFound(err) {
 			// Delete the corresponding virtualservice, as the service has been deleted.
-			err = v.virtualServiceClient.NetworkingV1alpha3().VirtualServices(namespace).Delete(name, nil)
+			err = v.virtualServiceClient.NetworkingV1alpha3().VirtualServices(namespace).Delete(context.Background(), name, metav1.DeleteOptions{})
 			if err != nil && !errors.IsNotFound(err) {
 				log.Error(err, "delete orphan virtualservice failed", "namespace", namespace, "name", service.Name)
 				return err
 			}
 
 			// delete the orphan strategy if there is any
-			err = v.servicemeshClient.ServicemeshV1alpha2().Strategies(namespace).Delete(name, nil)
+			err = v.servicemeshClient.ServicemeshV1alpha2().Strategies(namespace).Delete(context.Background(), name, metav1.DeleteOptions{})
 			if err != nil && !errors.IsNotFound(err) {
 				log.Error(err, "delete orphan strategy failed", "namespace", namespace, "name", service.Name)
 				return err
@@ -411,9 +412,9 @@ func (v *VirtualServiceController) syncService(key string) error {
 	}
 
 	if createVirtualService {
-		_, err = v.virtualServiceClient.NetworkingV1alpha3().VirtualServices(namespace).Create(newVirtualService)
+		_, err = v.virtualServiceClient.NetworkingV1alpha3().VirtualServices(namespace).Create(context.Background(), newVirtualService, metav1.CreateOptions{})
 	} else {
-		_, err = v.virtualServiceClient.NetworkingV1alpha3().VirtualServices(namespace).Update(newVirtualService)
+		_, err = v.virtualServiceClient.NetworkingV1alpha3().VirtualServices(namespace).Update(context.Background(), newVirtualService, metav1.UpdateOptions{})
 	}
 
 	if err != nil {

pkg/controller/virtualservice/virtualservice_controller_test.go

@@ -17,6 +17,7 @@ limitations under the License.
 package virtualservice
 
 import (
+	"context"
 	"fmt"
 	apiv1alpha3 "istio.io/api/networking/v1alpha3"
 	"istio.io/client-go/pkg/apis/networking/v1alpha3"
@@ -280,7 +281,7 @@ func (f *fixture) run_(serviceKey string, expectedVS *v1alpha3.VirtualService, s
 	}
 
 	if expectedVS != nil {
-		got, err := c.virtualServiceClient.NetworkingV1alpha3().VirtualServices(namespace).Get(name, metav1.GetOptions{})
+		got, err := c.virtualServiceClient.NetworkingV1alpha3().VirtualServices(namespace).Get(context.Background(), name, metav1.GetOptions{})
 		if err != nil {
 			f.t.Errorf("error getting virtualservice: %v", err)
 			return