parse redis config ending in k,kb,m,mb,g,gb

Author: polefishu

pkg/redisutil/admin.go

@@ -8,6 +8,8 @@ import (
 	"time"
 
 	"github.com/go-logr/logr"
+
+	"github.com/ucloud/redis-cluster-operator/pkg/utils"
 )
 
 const (
@@ -333,6 +335,24 @@ func (a *Admin) GetAllConfig(c IClient, addr string) (map[string]string, error)
 	return raw, nil
 }
 
+var parseConfigMap = map[string]int8{
+	"maxmemory":                  0,
+	"proto-max-bulk-len":         0,
+	"client-query-buffer-limit":  0,
+	"repl-backlog-size":          0,
+	"auto-aof-rewrite-min-size":  0,
+	"active-defrag-ignore-bytes": 0,
+	"hash-max-ziplist-entries":   0,
+	"hash-max-ziplist-value":     0,
+	"stream-node-max-bytes":      0,
+	"set-max-intset-entries":     0,
+	"zset-max-ziplist-entries":   0,
+	"zset-max-ziplist-value":     0,
+	"hll-sparse-max-bytes":       0,
+	// TODO parse client-output-buffer-limit
+	//"client-output-buffer-limit": 0,
+}
+
 // SetConfigIfNeed set redis config
 func (a *Admin) SetConfigIfNeed(newConfig map[string]string) error {
 	for addr, c := range a.Connections().GetAll() {
@@ -342,6 +362,14 @@ func (a *Admin) SetConfigIfNeed(newConfig map[string]string) error {
 		}
 
 		for key, value := range newConfig {
+			var err error
+			if _, ok := parseConfigMap[key]; ok {
+				value, err = utils.ParseRedisMemConf(value)
+				if err != nil {
+					a.log.Error(err, "redis config format err", "key", key, "value", value)
+					continue
+				}
+			}
 			if value != oldConfig[key] {
 				a.log.V(3).Info("CONFIG SET", key, value)
 				resp := c.Cmd("CONFIG", "SET", key, value)

pkg/utils/parse.go

@@ -0,0 +1,42 @@
+package utils
+
+import (
+	"strconv"
+	"strings"
+)
+
+func ParseRedisMemConf(p string) (string, error) {
+	var mul int64 = 1
+	u := strings.ToLower(p)
+	digits := u
+
+	if strings.HasSuffix(u, "k") {
+		digits = u[:len(u)-len("k")]
+		mul = 1000
+	} else if strings.HasSuffix(u, "kb") {
+		digits = u[:len(u)-len("kb")]
+		mul = 1024
+	} else if strings.HasSuffix(u, "m") {
+		digits = u[:len(u)-len("m")]
+		mul = 1000 * 1000
+	} else if strings.HasSuffix(u, "mb") {
+		digits = u[:len(u)-len("mb")]
+		mul = 1024 * 1024
+	} else if strings.HasSuffix(u, "g") {
+		digits = u[:len(u)-len("g")]
+		mul = 1000 * 1000 * 1000
+	} else if strings.HasSuffix(u, "gb") {
+		digits = u[:len(u)-len("gb")]
+		mul = 1024 * 1024 * 1024
+	} else if strings.HasSuffix(u, "b") {
+		digits = u[:len(u)-len("b")]
+		mul = 1
+	}
+
+	val, err := strconv.ParseInt(digits, 10, 64)
+	if err != nil {
+		return "", err
+	}
+
+	return strconv.FormatInt(val*mul, 10), nil
+}

pkg/utils/parse_test.go

@@ -0,0 +1,116 @@
+package utils
+
+import "testing"
+
+func TestParseRedisMemConf(t *testing.T) {
+	type args struct {
+		p string
+	}
+	tests := []struct {
+		name    string
+		args    args
+		want    string
+		wantErr bool
+	}{
+		{
+			name: "b",
+			args: args{
+				p: "12b",
+			},
+			want:    "12",
+			wantErr: false,
+		},
+		{
+			name: "digit",
+			args: args{
+				p: "1202",
+			},
+			want:    "1202",
+			wantErr: false,
+		},
+		{
+			name: "B",
+			args: args{
+				p: "12B",
+			},
+			want:    "12",
+			wantErr: false,
+		},
+		{
+			name: "k",
+			args: args{
+				p: "12k",
+			},
+			want:    "12000",
+			wantErr: false,
+		},
+		{
+			name: "kk",
+			args: args{
+				p: "12kk",
+			},
+			want:    "",
+			wantErr: true,
+		},
+		{
+			name: "kb",
+			args: args{
+				p: "12kb",
+			},
+			want:    "12288",
+			wantErr: false,
+		},
+		{
+			name: "Kb",
+			args: args{
+				p: "12Kb",
+			},
+			want:    "12288",
+			wantErr: false,
+		},
+		{
+			name: "m",
+			args: args{
+				p: "12m",
+			},
+			want:    "12000000",
+			wantErr: false,
+		},
+		{
+			name: "mB",
+			args: args{
+				p: "12mb",
+			},
+			want:    "12582912",
+			wantErr: false,
+		},
+		{
+			name: "g",
+			args: args{
+				p: "12g",
+			},
+			want:    "12000000000",
+			wantErr: false,
+		},
+		{
+			name: "gb",
+			args: args{
+				p: "12gb",
+			},
+			want:    "12884901888",
+			wantErr: false,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := ParseRedisMemConf(tt.args.p)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("ParseRedisMemConf() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if got != tt.want {
+				t.Errorf("ParseRedisMemConf() got = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}