testing-client

Signed-off-by: Shubham Gupta <[email protected]>

k8sutils/client.go

@@ -8,30 +8,24 @@ import (
 	"k8s.io/client-go/tools/clientcmd"
 )
 
+type K8sConfigProvider = func() (*rest.Config, error)
+
 // generateK8sClient create client for kubernetes
-func generateK8sClient() *kubernetes.Clientset {
-	config, err := generateK8sConfig()
-	if err != nil {
-		panic(err.Error())
-	}
-	clientset, err := kubernetes.NewForConfig(config)
+func generateK8sClient(configProvider K8sConfigProvider) (kubernetes.Interface, error) {
+	config, err := configProvider()
 	if err != nil {
-		panic(err.Error())
+		return nil, err
 	}
-	return clientset
+	return kubernetes.NewForConfig(config)
 }
 
 // generateK8sClient create Dynamic client for kubernetes
-func generateK8sDynamicClient() dynamic.Interface {
-	config, err := generateK8sConfig()
-	if err != nil {
-		panic(err.Error())
-	}
-	dynamicClientset, err := dynamic.NewForConfig(config)
+func generateK8sDynamicClient(configProvider K8sConfigProvider) (dynamic.Interface, error) {
+	config, err := configProvider()
 	if err != nil {
-		panic(err.Error())
+		return nil, err
 	}
-	return dynamicClientset
+	return dynamic.NewForConfig(config)
 }
 
 // generateK8sConfig will load the kube config file

k8sutils/finalizer.go

@@ -137,7 +137,12 @@ func AddRedisSentinelFinalizer(cr *redisv1beta2.RedisSentinel, cl client.Client)
 func finalizeRedisPVC(cr *redisv1beta2.Redis) error {
 	logger := finalizerLogger(cr.Namespace, RedisFinalizer)
 	PVCName := cr.Name + "-" + cr.Name + "-0"
-	err := generateK8sClient().CoreV1().PersistentVolumeClaims(cr.Namespace).Delete(context.TODO(), PVCName, metav1.DeleteOptions{})
+	client, err := generateK8sClient(generateK8sConfig)
+	if err != nil {
+		logger.Error(err, "Could not generate kubernetes client")
+		return err
+	}
+	err = client.CoreV1().PersistentVolumeClaims(cr.Namespace).Delete(context.TODO(), PVCName, metav1.DeleteOptions{})
 	if err != nil && !errors.IsNotFound(err) {
 		logger.Error(err, "Could not delete Persistent Volume Claim "+PVCName)
 		return err
@@ -148,10 +153,15 @@ func finalizeRedisPVC(cr *redisv1beta2.Redis) error {
 // finalizeRedisClusterPVC delete PVCs
 func finalizeRedisClusterPVC(cr *redisv1beta2.RedisCluster) error {
 	logger := finalizerLogger(cr.Namespace, RedisClusterFinalizer)
+	client, err := generateK8sClient(generateK8sConfig)
+	if err != nil {
+		logger.Error(err, "Could not generate kubernetes client")
+		return err
+	}
 	for _, role := range []string{"leader", "follower"} {
 		for i := 0; i < int(cr.Spec.GetReplicaCounts(role)); i++ {
 			PVCName := cr.Name + "-" + cr.Name + "-" + role + "-" + strconv.Itoa(i)
-			err := generateK8sClient().CoreV1().PersistentVolumeClaims(cr.Namespace).Delete(context.TODO(), PVCName, metav1.DeleteOptions{})
+			err := client.CoreV1().PersistentVolumeClaims(cr.Namespace).Delete(context.TODO(), PVCName, metav1.DeleteOptions{})
 			if err != nil && !errors.IsNotFound(err) {
 				logger.Error(err, "Could not delete Persistent Volume Claim "+PVCName)
 				return err
@@ -160,7 +170,7 @@ func finalizeRedisClusterPVC(cr *redisv1beta2.RedisCluster) error {
 		if cr.Spec.Storage.NodeConfVolume {
 			for i := 0; i < int(cr.Spec.GetReplicaCounts(role)); i++ {
 				PVCName := "node-conf" + cr.Name + "-" + role + "-" + strconv.Itoa(i)
-				err := generateK8sClient().CoreV1().PersistentVolumeClaims(cr.Namespace).Delete(context.TODO(), PVCName, metav1.DeleteOptions{})
+				err := client.CoreV1().PersistentVolumeClaims(cr.Namespace).Delete(context.TODO(), PVCName, metav1.DeleteOptions{})
 				if err != nil && !errors.IsNotFound(err) {
 					logger.Error(err, "Could not delete Persistent Volume Claim "+PVCName)
 					return err
@@ -175,9 +185,14 @@ func finalizeRedisClusterPVC(cr *redisv1beta2.RedisCluster) error {
 // finalizeRedisReplicationPVC delete PVCs
 func finalizeRedisReplicationPVC(cr *redisv1beta2.RedisReplication) error {
 	logger := finalizerLogger(cr.Namespace, RedisReplicationFinalizer)
+	client, err := generateK8sClient(generateK8sConfig)
+	if err != nil {
+		logger.Error(err, "Could not generate kubernetes client")
+		return err
+	}
 	for i := 0; i < int(cr.Spec.GetReplicationCounts("replication")); i++ {
 		PVCName := cr.Name + "-" + cr.Name + "-" + strconv.Itoa(i)
-		err := generateK8sClient().CoreV1().PersistentVolumeClaims(cr.Namespace).Delete(context.TODO(), PVCName, metav1.DeleteOptions{})
+		err := client.CoreV1().PersistentVolumeClaims(cr.Namespace).Delete(context.TODO(), PVCName, metav1.DeleteOptions{})
 		if err != nil && !errors.IsNotFound(err) {
 			logger.Error(err, "Could not delete Persistent Volume Claim "+PVCName)
 			return err

k8sutils/poddisruption.go

@@ -177,7 +177,12 @@ func patchPodDisruptionBudget(storedPdb *policyv1.PodDisruptionBudget, newPdb *p
 // createPodDisruptionBudget is a method to create PodDisruptionBudgets in Kubernetes
 func createPodDisruptionBudget(namespace string, pdb *policyv1.PodDisruptionBudget) error {
 	logger := pdbLogger(namespace, pdb.Name)
-	_, err := generateK8sClient().PolicyV1().PodDisruptionBudgets(namespace).Create(context.TODO(), pdb, metav1.CreateOptions{})
+	client, err := generateK8sClient(generateK8sConfig)
+	if err != nil {
+		logger.Error(err, "Could not generate kubernetes client")
+		return err
+	}
+	_, err = client.PolicyV1().PodDisruptionBudgets(namespace).Create(context.TODO(), pdb, metav1.CreateOptions{})
 	if err != nil {
 		logger.Error(err, "Redis PodDisruptionBudget creation failed")
 		return err
@@ -189,7 +194,12 @@ func createPodDisruptionBudget(namespace string, pdb *policyv1.PodDisruptionBudg
 // updatePodDisruptionBudget is a method to update PodDisruptionBudgets in Kubernetes
 func updatePodDisruptionBudget(namespace string, pdb *policyv1.PodDisruptionBudget) error {
 	logger := pdbLogger(namespace, pdb.Name)
-	_, err := generateK8sClient().PolicyV1().PodDisruptionBudgets(namespace).Update(context.TODO(), pdb, metav1.UpdateOptions{})
+	client, err := generateK8sClient(generateK8sConfig)
+	if err != nil {
+		logger.Error(err, "Could not generate kubernetes client")
+		return err
+	}
+	_, err = client.PolicyV1().PodDisruptionBudgets(namespace).Update(context.TODO(), pdb, metav1.UpdateOptions{})
 	if err != nil {
 		logger.Error(err, "Redis PodDisruptionBudget update failed")
 		return err
@@ -201,7 +211,12 @@ func updatePodDisruptionBudget(namespace string, pdb *policyv1.PodDisruptionBudg
 // deletePodDisruptionBudget is a method to delete PodDisruptionBudgets in Kubernetes
 func deletePodDisruptionBudget(namespace string, pdbName string) error {
 	logger := pdbLogger(namespace, pdbName)
-	err := generateK8sClient().PolicyV1().PodDisruptionBudgets(namespace).Delete(context.TODO(), pdbName, metav1.DeleteOptions{})
+	client, err := generateK8sClient(generateK8sConfig)
+	if err != nil {
+		logger.Error(err, "Could not generate kubernetes client")
+		return err
+	}
+	err = client.PolicyV1().PodDisruptionBudgets(namespace).Delete(context.TODO(), pdbName, metav1.DeleteOptions{})
 	if err != nil {
 		logger.Error(err, "Redis PodDisruption deletion failed")
 		return err
@@ -213,10 +228,15 @@ func deletePodDisruptionBudget(namespace string, pdbName string) error {
 // GetPodDisruptionBudget is a method to get PodDisruptionBudgets in Kubernetes
 func GetPodDisruptionBudget(namespace string, pdb string) (*policyv1.PodDisruptionBudget, error) {
 	logger := pdbLogger(namespace, pdb)
+	client, err := generateK8sClient(generateK8sConfig)
+	if err != nil {
+		logger.Error(err, "Could not generate kubernetes client")
+		return nil, err
+	}
 	getOpts := metav1.GetOptions{
 		TypeMeta: generateMetaInformation("PodDisruptionBudget", "policy/v1"),
 	}
-	pdbInfo, err := generateK8sClient().PolicyV1().PodDisruptionBudgets(namespace).Get(context.TODO(), pdb, getOpts)
+	pdbInfo, err := client.PolicyV1().PodDisruptionBudgets(namespace).Get(context.TODO(), pdb, getOpts)
 	if err != nil {
 		logger.V(1).Info("Redis PodDisruptionBudget get action failed")
 		return nil, err

k8sutils/redis-sentinel.go

@@ -283,6 +283,11 @@ func getSentinelEnvVariable(ctx context.Context, cr *redisv1beta2.RedisSentinel)
 
 func getRedisReplicationMasterIP(ctx context.Context, cr *redisv1beta2.RedisSentinel) string {
 	logger := generateRedisManagerLogger(cr.Namespace, cr.ObjectMeta.Name)
+	dClient, err := generateK8sDynamicClient(generateK8sConfig)
+	if err != nil {
+		logger.Error(err, "Failed to generate dynamic client")
+		return ""
+	}
 
 	replicationName := cr.Spec.RedisSentinelConfig.RedisReplicationName
 	replicationNamespace := cr.Namespace
@@ -291,7 +296,7 @@ func getRedisReplicationMasterIP(ctx context.Context, cr *redisv1beta2.RedisSent
 	var realMasterPod string
 
 	// Get Request on Dynamic Client
-	customObject, err := generateK8sDynamicClient().Resource(schema.GroupVersionResource{
+	customObject, err := dClient.Resource(schema.GroupVersionResource{
 		Group:    "redis.redis.opstreelabs.in",
 		Version:  "v1beta2",
 		Resource: "redisreplications",

k8sutils/redis.go

@@ -27,7 +27,12 @@ type RedisDetails struct {
 // getRedisServerIP will return the IP of redis service
 func getRedisServerIP(redisInfo RedisDetails) string {
 	logger := generateRedisManagerLogger(redisInfo.Namespace, redisInfo.PodName)
-	redisPod, err := generateK8sClient().CoreV1().Pods(redisInfo.Namespace).Get(context.TODO(), redisInfo.PodName, metav1.GetOptions{})
+	client, err := generateK8sClient(generateK8sConfig)
+	if err != nil {
+		logger.Error(err, "Error in getting k8s client")
+		return ""
+	}
+	redisPod, err := client.CoreV1().Pods(redisInfo.Namespace).Get(context.TODO(), redisInfo.PodName, metav1.GetOptions{})
 	if err != nil {
 		logger.Error(err, "Error in getting redis pod IP")
 	}
@@ -358,6 +363,11 @@ func executeCommand(cr *redisv1beta2.RedisCluster, cmd []string, podName string)
 		execErr bytes.Buffer
 	)
 	logger := generateRedisManagerLogger(cr.Namespace, cr.ObjectMeta.Name)
+	client, err := generateK8sClient(generateK8sConfig)
+	if err != nil {
+		logger.Error(err, "Could not generate kubernetes client")
+		return
+	}
 	config, err := generateK8sConfig()
 	if err != nil {
 		logger.Error(err, "Could not find pod to execute")
@@ -369,7 +379,7 @@ func executeCommand(cr *redisv1beta2.RedisCluster, cmd []string, podName string)
 		return
 	}
 
-	req := generateK8sClient().CoreV1().RESTClient().Post().Resource("pods").Name(podName).Namespace(cr.Namespace).SubResource("exec")
+	req := client.CoreV1().RESTClient().Post().Resource("pods").Name(podName).Namespace(cr.Namespace).SubResource("exec")
 	req.VersionedParams(&corev1.PodExecOptions{
 		Container: pod.Spec.Containers[targetContainer].Name,
 		Command:   cmd,
@@ -397,7 +407,12 @@ func executeCommand(cr *redisv1beta2.RedisCluster, cmd []string, podName string)
 // getContainerID will return the id of container from pod
 func getContainerID(cr *redisv1beta2.RedisCluster, podName string) (int, *corev1.Pod) {
 	logger := generateRedisManagerLogger(cr.Namespace, cr.ObjectMeta.Name)
-	pod, err := generateK8sClient().CoreV1().Pods(cr.Namespace).Get(context.TODO(), podName, metav1.GetOptions{})
+	client, err := generateK8sClient(generateK8sConfig)
+	if err != nil {
+		logger.Error(err, "Could not generate kubernetes client")
+		return -1, nil
+	}
+	pod, err := client.CoreV1().Pods(cr.Namespace).Get(context.TODO(), podName, metav1.GetOptions{})
 	if err != nil {
 		logger.Error(err, "Could not get pod info")
 	}

k8sutils/secrets.go

@@ -17,7 +17,12 @@ var log = logf.Log.WithName("controller_redis")
 // getRedisPassword method will return the redis password
 func getRedisPassword(namespace, name, secretKey string) (string, error) {
 	logger := secretLogger(namespace, name)
-	secretName, err := generateK8sClient().CoreV1().Secrets(namespace).Get(context.TODO(), name, metav1.GetOptions{})
+	client, err := generateK8sClient(generateK8sConfig)
+	if err != nil {
+		logger.Error(err, "Could not generate kubernetes client")
+		return "", err
+	}
+	secretName, err := client.CoreV1().Secrets(namespace).Get(context.TODO(), name, metav1.GetOptions{})
 	if err != nil {
 		logger.Error(err, "Failed in getting existing secret for redis")
 		return "", err
@@ -36,9 +41,13 @@ func secretLogger(namespace string, name string) logr.Logger {
 }
 
 func getRedisTLSConfig(cr *redisv1beta2.RedisCluster, redisInfo RedisDetails) *tls.Config {
+	client, err := generateK8sClient(generateK8sConfig)
+	if err != nil {
+		return nil
+	}
 	if cr.Spec.TLS != nil {
 		reqLogger := log.WithValues("Request.Namespace", cr.Namespace, "Request.Name", cr.ObjectMeta.Name)
-		secretName, err := generateK8sClient().CoreV1().Secrets(cr.Namespace).Get(context.TODO(), cr.Spec.TLS.Secret.SecretName, metav1.GetOptions{})
+		secretName, err := client.CoreV1().Secrets(cr.Namespace).Get(context.TODO(), cr.Spec.TLS.Secret.SecretName, metav1.GetOptions{})
 		if err != nil {
 			reqLogger.Error(err, "Failed in getting TLS secret for redis")
 		}
@@ -84,9 +93,13 @@ func getRedisTLSConfig(cr *redisv1beta2.RedisCluster, redisInfo RedisDetails) *t
 }
 
 func getRedisReplicationTLSConfig(cr *redisv1beta2.RedisReplication, redisInfo RedisDetails) *tls.Config {
+	client, err := generateK8sClient(generateK8sConfig)
+	if err != nil {
+		return nil
+	}
 	if cr.Spec.TLS != nil {
 		reqLogger := log.WithValues("Request.Namespace", cr.Namespace, "Request.Name", cr.ObjectMeta.Name)
-		secretName, err := generateK8sClient().CoreV1().Secrets(cr.Namespace).Get(context.TODO(), cr.Spec.TLS.Secret.SecretName, metav1.GetOptions{})
+		secretName, err := client.CoreV1().Secrets(cr.Namespace).Get(context.TODO(), cr.Spec.TLS.Secret.SecretName, metav1.GetOptions{})
 		if err != nil {
 			reqLogger.Error(err, "Failed in getting TLS secret for redis")
 		}

k8sutils/services.go

@@ -89,7 +89,12 @@ func generateServiceType(k8sServiceType string) corev1.ServiceType {
 // createService is a method to create service is Kubernetes
 func createService(namespace string, service *corev1.Service) error {
 	logger := serviceLogger(namespace, service.Name)
-	_, err := generateK8sClient().CoreV1().Services(namespace).Create(context.TODO(), service, metav1.CreateOptions{})
+	client, err := generateK8sClient(generateK8sConfig)
+	if err != nil {
+		logger.Error(err, "Could not generate kubernetes client")
+		return err
+	}
+	_, err = client.CoreV1().Services(namespace).Create(context.TODO(), service, metav1.CreateOptions{})
 	if err != nil {
 		logger.Error(err, "Redis service creation is failed")
 		return err
@@ -101,7 +106,12 @@ func createService(namespace string, service *corev1.Service) error {
 // updateService is a method to update service is Kubernetes
 func updateService(namespace string, service *corev1.Service) error {
 	logger := serviceLogger(namespace, service.Name)
-	_, err := generateK8sClient().CoreV1().Services(namespace).Update(context.TODO(), service, metav1.UpdateOptions{})
+	client, err := generateK8sClient(generateK8sConfig)
+	if err != nil {
+		logger.Error(err, "Could not generate kubernetes client")
+		return err
+	}
+	_, err = client.CoreV1().Services(namespace).Update(context.TODO(), service, metav1.UpdateOptions{})
 	if err != nil {
 		logger.Error(err, "Redis service update failed")
 		return err
@@ -113,10 +123,15 @@ func updateService(namespace string, service *corev1.Service) error {
 // getService is a method to get service is Kubernetes
 func getService(namespace string, service string) (*corev1.Service, error) {
 	logger := serviceLogger(namespace, service)
+	client, err := generateK8sClient(generateK8sConfig)
+	if err != nil {
+		logger.Error(err, "Could not generate kubernetes client")
+		return nil, err
+	}
 	getOpts := metav1.GetOptions{
 		TypeMeta: generateMetaInformation("Service", "v1"),
 	}
-	serviceInfo, err := generateK8sClient().CoreV1().Services(namespace).Get(context.TODO(), service, getOpts)
+	serviceInfo, err := client.CoreV1().Services(namespace).Get(context.TODO(), service, getOpts)
 	if err != nil {
 		logger.V(1).Info("Redis service get action is failed")
 		return nil, err