Updated th redis for Binding Policy (#910)

Author: kunal-511

backend/redis/redis.go

@@ -296,6 +296,12 @@ func StoreBindingPolicy(policy *BindingPolicyCache) error {
 		return fmt.Errorf("cannot store nil binding policy")
 	}
 
+	// Check if Redis is available
+	if err := rdb.Ping(ctx).Err(); err != nil {
+		log.LogWarn("redis not available, skipping cache store", zap.Error(err))
+		return nil // Don't fail the operation if Redis is down
+	}
+
 	// Marshal the policy to JSON
 	jsonData, err := json.Marshal(policy)
 	if err != nil {
@@ -319,6 +325,11 @@ func StoreBindingPolicy(policy *BindingPolicyCache) error {
 
 // GetBindingPolicy retrieves a binding policy from Redis by name
 func GetBindingPolicy(name string) (*BindingPolicyCache, error) {
+	// Check if Redis is available
+	if err := rdb.Ping(ctx).Err(); err != nil {
+		return nil, fmt.Errorf("redis not available: %v", err)
+	}
+
 	val, err := rdb.HGet(ctx, BindingPolicyHashKey, name).Result()
 	if err == redis.Nil {
 		return nil, nil // Policy not found
@@ -336,11 +347,20 @@ func GetBindingPolicy(name string) (*BindingPolicyCache, error) {
 
 // GetAllBindingPolicies retrieves all binding policies from Redis
 func GetAllBindingPolicies() ([]*BindingPolicyCache, error) {
+	// Check if Redis is available
+	if err := rdb.Ping(ctx).Err(); err != nil {
+		return nil, fmt.Errorf("redis not available: %v", err)
+	}
+
 	values, err := rdb.HGetAll(ctx, BindingPolicyHashKey).Result()
 	if err != nil {
 		return nil, fmt.Errorf("failed to get all binding policies from Redis: %v", err)
 	}
 
+	if len(values) == 0 {
+		return nil, nil
+	}
+
 	policies := make([]*BindingPolicyCache, 0, len(values))
 	for _, val := range values {
 		var policy BindingPolicyCache
@@ -356,6 +376,12 @@ func GetAllBindingPolicies() ([]*BindingPolicyCache, error) {
 
 // DeleteBindingPolicy removes a binding policy from Redis
 func DeleteBindingPolicy(name string) error {
+	// Check if Redis is available
+	if err := rdb.Ping(ctx).Err(); err != nil {
+		log.LogWarn("redis not available, skipping cache delete", zap.Error(err))
+		return nil // Don't fail the operation if Redis is down
+	}
+
 	err := rdb.HDel(ctx, BindingPolicyHashKey, name).Err()
 	if err != nil {
 		return fmt.Errorf("failed to delete binding policy from Redis: %v", err)
@@ -365,6 +391,12 @@ func DeleteBindingPolicy(name string) error {
 
 // DeleteAllBindingPolicies removes all binding policies from Redis
 func DeleteAllBindingPolicies() error {
+	// Check if Redis is available
+	if err := rdb.Ping(ctx).Err(); err != nil {
+		log.LogWarn("redis not available, skipping cache delete", zap.Error(err))
+		return nil // Don't fail the operation if Redis is down
+	}
+
 	err := rdb.Del(ctx, BindingPolicyHashKey).Err()
 	if err != nil {
 		return fmt.Errorf("failed to delete all binding policies from Redis: %v", err)

backend/wds/bp/handlers.go

@@ -59,7 +59,7 @@ func GetBindingPolicies(namespace string) ([]map[string]interface{}, error) {
 	cachedPolicies, err := redis.GetAllBindingPolicies()
 	if err != nil {
 		log.LogWarn("failed to get binding policies from Redis cache", zap.Error(err))
-	} else if len(cachedPolicies) > 0 {
+	} else if cachedPolicies != nil && len(cachedPolicies) > 0 {
 		// Convert cached policies to response format
 		responseArray := make([]map[string]interface{}, len(cachedPolicies))
 		for i, bpolicy := range cachedPolicies {
@@ -603,6 +603,7 @@ func CreateBp(ctx *gin.Context) {
 	if err != nil {
 		log.LogError(err.Error())
 		ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
 	}
 
 	// After successful creation, store in Redis
@@ -619,6 +620,7 @@ func CreateBp(ctx *gin.Context) {
 		log.LogWarn("failed to cache new binding policy", zap.Error(err))
 	}
 
+	ctx.JSON(http.StatusOK, gin.H{"message": fmt.Sprintf("Created binding policy '%s' successfully", bp.Name)})
 }
 
 // DeleteBp deletes a BindingPolicy by name and namespace

backend/wds/bp/utils.go

@@ -346,13 +346,50 @@ func watchOnBps() {
 				}
 				log.LogInfo("BP modified: ", zap.String("name", bp.Name))
 
+				// Update the cache with the modified binding policy
+				status := "inactive"
+				if bp.ObjectMeta.Generation == bp.Status.ObservedGeneration {
+					status = "active"
+				}
+
+				cachedPolicy := &redis.BindingPolicyCache{
+					Name:              bp.Name,
+					Namespace:         bp.Namespace,
+					Status:            status,
+					BindingMode:       "Downsync",
+					Clusters:          extractTargetClusters(bp),
+					Workloads:         extractWorkloads(bp),
+					CreationTimestamp: bp.CreationTimestamp.Format("2006-01-02T15:04:05Z"),
+					RawYAML:           "", // We don't have the raw YAML in watch events
+				}
+
+				if err := redis.StoreBindingPolicy(cachedPolicy); err != nil {
+					log.LogWarn("failed to update binding policy in cache", zap.Error(err))
+				}
+
 			case "ADDED":
 				bp, _ := event.Object.(*v1alpha1.BindingPolicy)
 				log.LogInfo("BP added: ", zap.String("name", bp.Name))
 
+				// Add the new binding policy to cache
+				cachedPolicy := &redis.BindingPolicyCache{
+					Name:              bp.Name,
+					Namespace:         bp.Namespace,
+					Status:            "inactive", // New policies start as inactive
+					BindingMode:       "Downsync",
+					Clusters:          extractTargetClusters(bp),
+					Workloads:         extractWorkloads(bp),
+					CreationTimestamp: bp.CreationTimestamp.Format("2006-01-02T15:04:05Z"),
+					RawYAML:           "", // We don't have the raw YAML in watch events
+				}
+
+				if err := redis.StoreBindingPolicy(cachedPolicy); err != nil {
+					log.LogWarn("failed to cache new binding policy from watch", zap.Error(err))
+				}
+
 			case "DELETED":
 				bp, _ := event.Object.(*v1alpha1.BindingPolicy)
-				err := redis.DeleteBpcmd(bp.Name)
+				err := redis.DeleteBindingPolicy(bp.Name)
 				if err != nil {
 					log.LogError("Error deleting bp from redis", zap.String("error", err.Error()))
 				}