Merge pull request #434 from pych/custom-port-capability

Custom port capability

api/redisfailover/v1/defaults.go

@@ -6,7 +6,7 @@ const (
 	defaultSentinelExporterImage = "quay.io/oliver006/redis_exporter:v1.43.0"
 	defaultExporterImage         = "quay.io/oliver006/redis_exporter:v1.43.0"
 	defaultImage                 = "redis:6.2.6-alpine"
-	defaultRedisPort             = "6379"
+	defaultRedisPort             = 6379
 )
 
 var (

api/redisfailover/v1/types.go

@@ -40,6 +40,7 @@ type RedisSettings struct {
 	Image                         string                        `json:"image,omitempty"`
 	ImagePullPolicy               corev1.PullPolicy             `json:"imagePullPolicy,omitempty"`
 	Replicas                      int32                         `json:"replicas,omitempty"`
+	Port                          int32                         `json:"port,omitempty"`
 	Resources                     corev1.ResourceRequirements   `json:"resources,omitempty"`
 	CustomConfig                  []string                      `json:"customConfig,omitempty"`
 	CustomCommandRenames          []RedisCommandRename          `json:"customCommandRenames,omitempty"`

api/redisfailover/v1/validate.go

@@ -3,6 +3,7 @@ package v1
 import (
 	"errors"
 	"fmt"
+	"strconv"
 )
 
 const (
@@ -22,7 +23,7 @@ func (r *RedisFailover) Validate() error {
 		}
 
 		if r.Spec.BootstrapNode.Port == "" {
-			r.Spec.BootstrapNode.Port = defaultRedisPort
+			r.Spec.BootstrapNode.Port = strconv.Itoa(defaultRedisPort)
 		}
 		initialRedisCustomConfig = bootstrappingRedisCustomConfig
 	}
@@ -41,6 +42,10 @@ func (r *RedisFailover) Validate() error {
 		r.Spec.Redis.Replicas = defaultRedisNumber
 	}
 
+	if r.Spec.Redis.Port <= 0 {
+		r.Spec.Redis.Port = defaultRedisPort
+	}
+
 	if r.Spec.Sentinel.Replicas <= 0 {
 		r.Spec.Sentinel.Replicas = defaultSentinelNumber
 	}

api/redisfailover/v1/validate_test.go

@@ -104,6 +104,7 @@ func TestValidate(t *testing.T) {
 						Redis: RedisSettings{
 							Image:    defaultImage,
 							Replicas: defaultRedisNumber,
+							Port:     defaultRedisPort,
 							Exporter: RedisExporter{
 								Image: defaultExporterImage,
 							},

example/redisfailover/custom-port.yaml

@@ -0,0 +1,21 @@
+---
+apiVersion: v1
+kind: Namespace
+metadata:
+  name: ports
+---
+apiVersion: databases.spotahome.com/v1
+kind: RedisFailover
+metadata:
+  name: redis-ports
+  namespace: ports
+spec:
+  redis:
+    exporter:
+      enabled: true
+    port: 12345
+    replicas: 3
+  sentinel:
+    exporter:
+      enabled: true
+    replicas: 3

manifests/databases.spotahome.com_redisfailovers.yaml

@@ -1473,6 +1473,9 @@ spec:
                     additionalProperties:
                       type: string
                     type: object
+                  port:
+                    format: int32
+                    type: integer
                   priorityClassName:
                     type: string
                   replicas:

operator/redisfailover/checker.go

@@ -2,6 +2,7 @@ package redisfailover
 
 import (
 	"errors"
+	"strconv"
 	"time"
 
 	redisfailoverv1 "github.com/spotahome/redis-operator/api/redisfailover/v1"
@@ -23,9 +24,9 @@ func (r *RedisFailoverHandler) UpdateRedisesPods(rf *redisfailoverv1.RedisFailov
 		masterIP, _ = r.rfChecker.GetMasterIP(rf)
 	}
 	// No perform updates when nodes are syncing, still not connected, etc.
-	for _, rp := range redises {
-		if rp != masterIP {
-			ready, err := r.rfChecker.CheckRedisSlavesReady(rp, rf)
+	for _, rip := range redises {
+		if rip != masterIP {
+			ready, err := r.rfChecker.CheckRedisSlavesReady(rip, rf)
 			if err != nil {
 				return err
 			}
@@ -169,8 +170,10 @@ func (r *RedisFailoverHandler) CheckAndHeal(rf *redisfailoverv1.RedisFailover) e
 	if err != nil {
 		return err
 	}
+
+	port := getRedisPort(rf.Spec.Redis.Port)
 	for _, sip := range sentinels {
-		if err := r.rfChecker.CheckSentinelMonitor(sip, master); err != nil {
+		if err := r.rfChecker.CheckSentinelMonitor(sip, master, port); err != nil {
 			r.logger.Debug("Sentinel is not monitoring the correct master")
 			if err := r.rfHealer.NewSentinelMonitor(sip, master, rf); err != nil {
 				return err
@@ -260,3 +263,7 @@ func (r *RedisFailoverHandler) checkAndHealSentinels(rf *redisfailoverv1.RedisFa
 	}
 	return nil
 }
+
+func getRedisPort(p int32) string {
+	return strconv.Itoa(int(p))
+}

operator/redisfailover/checker_test.go

@@ -344,14 +344,14 @@ func TestCheckAndHeal(t *testing.T) {
 					if test.bootstrapping {
 						mrfc.On("CheckSentinelMonitor", sentinel, bootstrapMaster, bootstrapMasterPort).Once().Return(nil)
 					} else {
-						mrfc.On("CheckSentinelMonitor", sentinel, master).Once().Return(nil)
+						mrfc.On("CheckSentinelMonitor", sentinel, master, "0").Once().Return(nil)
 					}
 				} else {
 					if test.bootstrapping {
 						mrfc.On("CheckSentinelMonitor", sentinel, bootstrapMaster, bootstrapMasterPort).Once().Return(errors.New(""))
 						mrfh.On("NewSentinelMonitorWithPort", sentinel, bootstrapMaster, bootstrapMasterPort, rf).Once().Return(nil)
 					} else {
-						mrfc.On("CheckSentinelMonitor", sentinel, master).Once().Return(errors.New(""))
+						mrfc.On("CheckSentinelMonitor", sentinel, master, "0").Once().Return(errors.New(""))
 						mrfh.On("NewSentinelMonitor", sentinel, master, rf).Once().Return(nil)
 					}
 				}

operator/redisfailover/service/check.go

@@ -3,6 +3,7 @@ package service
 import (
 	"errors"
 	"fmt"
+	"strconv"
 	"time"
 
 	appsv1 "k8s.io/api/apps/v1"
@@ -104,6 +105,7 @@ func (r *RedisFailoverChecker) CheckAllSlavesFromMaster(master string, rf *redis
 		return err
 	}
 
+	rport := getRedisPort(rf.Spec.Redis.Port)
 	for _, rp := range rps.Items {
 		if rp.Status.PodIP == master {
 			err = r.setMasterLabelIfNecessary(rf.Namespace, rp)
@@ -117,7 +119,7 @@ func (r *RedisFailoverChecker) CheckAllSlavesFromMaster(master string, rf *redis
 			}
 		}
 
-		slave, err := r.redisClient.GetSlaveOf(rp.Status.PodIP, password)
+		slave, err := r.redisClient.GetSlaveOf(rp.Status.PodIP, rport, password)
 		if err != nil {
 			r.logger.Errorf("Get slave of master failed, maybe this node is not ready, pod ip: %s", rp.Status.PodIP)
 			return err
@@ -181,8 +183,9 @@ func (r *RedisFailoverChecker) GetMasterIP(rf *redisfailoverv1.RedisFailover) (s
 	}
 
 	masters := []string{}
+	rport := getRedisPort(rf.Spec.Redis.Port)
 	for _, rip := range rips {
-		master, err := r.redisClient.IsMaster(rip, password)
+		master, err := r.redisClient.IsMaster(rip, rport, password)
 		if err != nil {
 			r.logger.Errorf("Get redis info failed, maybe this node is not ready, pod ip: %s", rip)
 			continue
@@ -211,8 +214,9 @@ func (r *RedisFailoverChecker) GetNumberMasters(rf *redisfailoverv1.RedisFailove
 		return nMasters, err
 	}
 
+	rport := getRedisPort(rf.Spec.Redis.Port)
 	for _, rip := range rips {
-		master, err := r.redisClient.IsMaster(rip, password)
+		master, err := r.redisClient.IsMaster(rip, rport, password)
 		if err != nil {
 			r.logger.Errorf("Get redis info failed, maybe this node is not ready, pod ip: %s", rip)
 			continue
@@ -288,9 +292,10 @@ func (r *RedisFailoverChecker) GetRedisesSlavesPods(rf *redisfailoverv1.RedisFai
 		return redises, err
 	}
 
+	rport := getRedisPort(rf.Spec.Redis.Port)
 	for _, rp := range rps.Items {
 		if rp.Status.Phase == corev1.PodRunning && rp.DeletionTimestamp == nil { // Only work with running
-			master, err := r.redisClient.IsMaster(rp.Status.PodIP, password)
+			master, err := r.redisClient.IsMaster(rp.Status.PodIP, rport, password)
 			if err != nil {
 				return []string{}, err
 			}
@@ -314,9 +319,10 @@ func (r *RedisFailoverChecker) GetRedisesMasterPod(rFailover *redisfailoverv1.Re
 		return "", err
 	}
 
+	rport := getRedisPort(rFailover.Spec.Redis.Port)
 	for _, rp := range rps.Items {
 		if rp.Status.Phase == corev1.PodRunning && rp.DeletionTimestamp == nil { // Only work with running
-			master, err := r.redisClient.IsMaster(rp.Status.PodIP, password)
+			master, err := r.redisClient.IsMaster(rp.Status.PodIP, rport, password)
 			if err != nil {
 				return "", err
 			}
@@ -370,5 +376,10 @@ func (r *RedisFailoverChecker) CheckRedisSlavesReady(ip string, rFailover *redis
 		return false, err
 	}
 
-	return r.redisClient.SlaveIsReady(ip, password)
+	port := getRedisPort(rFailover.Spec.Redis.Port)
+	return r.redisClient.SlaveIsReady(ip, port, password)
+}
+
+func getRedisPort(p int32) string {
+	return strconv.Itoa(int(p))
 }