wip

Author: eguzki

api/v1alpha1/limitador_types.go

@@ -17,7 +17,6 @@ limitations under the License.
 package v1alpha1
 
 import (
-	"fmt"
 	"reflect"
 
 	"github.com/go-logr/logr"
@@ -145,17 +144,6 @@ type LimitadorList struct {
 // +kubebuilder:validation:Enum=NONE;DRAFT_VERSION_03
 type RateLimitHeadersType string
 
-// StorageType defines the valid options for storage
-// +kubebuilder:validation:Enum=memory;redis;redis_cached;disk
-type StorageType string
-
-const (
-	StorageTypeInMemory    StorageType = "memory"
-	StorageTypeRedis       StorageType = "redis"
-	StorageTypeRedisCached StorageType = "redis_cached"
-	StorageTypeDisk        StorageType = "disk"
-)
-
 // Storage contains the options for Limitador counters database or in-memory data storage
 type Storage struct {
 	// +optional
@@ -168,47 +156,6 @@ type Storage struct {
 	Disk *DiskSpec `json:"disk,omitempty"`
 }
 
-func (s *Storage) Validate() bool {
-	return s.Redis != nil && s.Redis.ConfigSecretRef != nil ||
-		s.RedisCached != nil && s.RedisCached.ConfigSecretRef != nil
-}
-
-func (s *Storage) SecretRef() *corev1.ObjectReference {
-	if s.Redis != nil {
-		return s.Redis.ConfigSecretRef
-	}
-	return s.RedisCached.ConfigSecretRef
-}
-
-func (s *Storage) Config(url string) []string {
-	if s.Redis != nil {
-		return []string{string(StorageTypeRedis), url}
-	}
-
-	if s.RedisCached != nil {
-		params := []string{string(StorageTypeRedisCached), url}
-
-		if s.RedisCached.Options != nil {
-			options := reflect.ValueOf(*s.RedisCached.Options)
-			typesOf := options.Type()
-			for i := 0; i < options.NumField(); i++ {
-				if !options.Field(i).IsNil() {
-					var value interface{} = options.Field(i).Elem()
-					params = append(
-						params,
-						fmt.Sprintf(
-							"--%s %d",
-							helpers.ToKebabCase(typesOf.Field(i).Name),
-							value))
-				}
-			}
-		}
-		return params
-	}
-
-	return []string{string(StorageTypeInMemory)}
-}
-
 type Redis struct {
 	// +ConfigSecretRef refers to the secret holding the URL for Redis.
 	// +optional
@@ -331,6 +278,21 @@ type Ports struct {
 	GRPC int32 `json:"grpc,omitempty"`
 }
 
+type PodDisruptionBudgetType struct {
+	// An eviction is allowed if at most "maxUnavailable" limitador pods
+	// are unavailable after the eviction, i.e. even in absence of
+	// the evicted pod. For example, one can prevent all voluntary evictions
+	// by specifying 0. This is a mutually exclusive setting with "minAvailable".
+	// +optional
+	MaxUnavailable *intstr.IntOrString `json:"maxUnavailable,omitempty"`
+	// An eviction is allowed if at least "minAvailable" limitador pods will
+	// still be available after the eviction, i.e. even in the absence of
+	// the evicted pod.  So for example you can prevent all voluntary
+	// evictions by specifying "100%".
+	// +optional
+	MinAvailable *intstr.IntOrString `json:"minAvailable,omitempty"`
+}
+
 func (s *LimitadorStatus) Equals(other *LimitadorStatus, logger logr.Logger) bool {
 	if s.ObservedGeneration != other.ObservedGeneration {
 		diff := cmp.Diff(s.ObservedGeneration, other.ObservedGeneration)
@@ -359,18 +321,3 @@ func (s *LimitadorStatus) Equals(other *LimitadorStatus, logger logr.Logger) boo
 func init() {
 	SchemeBuilder.Register(&Limitador{}, &LimitadorList{})
 }
-
-type PodDisruptionBudgetType struct {
-	// An eviction is allowed if at most "maxUnavailable" limitador pods
-	// are unavailable after the eviction, i.e. even in absence of
-	// the evicted pod. For example, one can prevent all voluntary evictions
-	// by specifying 0. This is a mutually exclusive setting with "minAvailable".
-	// +optional
-	MaxUnavailable *intstr.IntOrString `json:"maxUnavailable,omitempty"`
-	// An eviction is allowed if at least "minAvailable" limitador pods will
-	// still be available after the eviction, i.e. even in the absence of
-	// the evicted pod.  So for example you can prevent all voluntary
-	// evictions by specifying "100%".
-	// +optional
-	MinAvailable *intstr.IntOrString `json:"minAvailable,omitempty"`
-}

api/v1alpha1/limitador_types_test.go

@@ -1,8 +1,6 @@
 package v1alpha1
 
 import (
-	"fmt"
-	"strconv"
 	"testing"
 
 	"github.com/go-logr/logr"
@@ -94,84 +92,6 @@ func TestLimitadorLimits(t *testing.T) {
 	})
 }
 
-func TestStorageSecretRef(t *testing.T) {
-	t.Run("test redis secret ref is returned if not nil", func(subT *testing.T) {
-		var redisSecretRef = &corev1.ObjectReference{Name: "redis"}
-		s := Storage{Redis: &Redis{ConfigSecretRef: redisSecretRef}}
-		assert.DeepEqual(subT, s.SecretRef(), redisSecretRef)
-	})
-
-	t.Run("test redis cached ref is returned if redis nil", func(subT *testing.T) {
-		var redisCachedSecretRef = &corev1.ObjectReference{Name: "redisCached"}
-		s := Storage{RedisCached: &RedisCached{ConfigSecretRef: redisCachedSecretRef}}
-		assert.DeepEqual(subT, s.SecretRef(), redisCachedSecretRef)
-	})
-}
-
-func TestStorageValidate(t *testing.T) {
-	t.Run("test false if redis is nil", func(subT *testing.T) {
-		s := Storage{}
-		assert.Equal(subT, s.Validate(), false)
-	})
-
-	t.Run("test false if redis secret ref is nil", func(subT *testing.T) {
-		s := Storage{Redis: &Redis{}}
-		assert.Equal(subT, s.Validate(), false)
-	})
-
-	t.Run("test true if redis secret ref is not nil", func(subT *testing.T) {
-		s := Storage{Redis: &Redis{ConfigSecretRef: &corev1.ObjectReference{}}}
-		assert.Equal(subT, s.Validate(), true)
-	})
-
-	t.Run("test false if redis cached is nil", func(subT *testing.T) {
-		s := Storage{Redis: &Redis{}}
-		assert.Equal(subT, s.Validate(), false)
-	})
-
-	t.Run("test false if redis cached secret ref is nil", func(subT *testing.T) {
-		s := Storage{RedisCached: &RedisCached{}}
-		assert.Equal(subT, s.Validate(), false)
-	})
-
-	t.Run("test true if redis secret ref is not nil", func(subT *testing.T) {
-		s := Storage{RedisCached: &RedisCached{ConfigSecretRef: &corev1.ObjectReference{}}}
-		assert.Equal(subT, s.Validate(), true)
-	})
-}
-
-func TestStorageConfig(t *testing.T) {
-	const url = "test"
-
-	t.Run("test redis storage type returned if redis is not nil", func(subT *testing.T) {
-		s := Storage{Redis: &Redis{}}
-		assert.DeepEqual(subT, s.Config(url), []string{string(StorageTypeRedis), url})
-	})
-
-	t.Run("test redis cached storage type returned if redis cached is not nil", func(subT *testing.T) {
-		s := Storage{RedisCached: &RedisCached{}}
-		assert.DeepEqual(subT, s.Config(url), []string{string(StorageTypeRedisCached), url})
-	})
-
-	t.Run("test redis cached storage type with options returned", func(subT *testing.T) {
-		var option = 4040
-		s := Storage{RedisCached: &RedisCached{Options: &RedisCachedOptions{
-			TTL:         &option,
-			Ratio:       &option,
-			FlushPeriod: &option,
-			MaxCached:   &option,
-		}}}
-		assert.DeepEqual(subT, s.Config(url), []string{string(StorageTypeRedisCached), url, fmt.Sprintf("--ttl %s", strconv.Itoa(option)),
-			fmt.Sprintf("--ratio %s", strconv.Itoa(option)), fmt.Sprintf("--flush-period %s", strconv.Itoa(option)),
-			fmt.Sprintf("--max-cached %s", strconv.Itoa(option))})
-	})
-
-	t.Run("test redis cached storage type returned if redis cached is not nil", func(subT *testing.T) {
-		s := Storage{}
-		assert.DeepEqual(subT, s.Config(url), []string{string(StorageTypeInMemory)})
-	})
-}
-
 func TestLimitadorStatusEquals(t *testing.T) {
 	var (
 		conditions = []metav1.Condition{