Skip to content
This repository was archived by the owner on Oct 10, 2026. It is now read-only.

Commit 6e4b262

Browse files
committed
feat(tls): add --cluster-domain flag for cert SAN templating
Address review feedback from lexfrei (Blocker B2) on operator/redisfailover/service/generator.go: the FQDN SAN entries hardcoded ".svc.cluster.local", so on any Kubernetes cluster running with a non-default --cluster-domain (cozystack defaults to "cozy.local"; on-prem clusters routinely use "cluster.internal" or a site-specific value) the cert-manager Certificate produced by the operator-managed path did not cover the FQDNs clients actually resolve, and TLS verification failed for every routed FQDN dial. The bring-your-own-Secret path was unaffected because the chart renders its own Certificate with the configurable domain, but the operator-managed path stayed broken for non-default clusters. Plumbing: - New `--cluster-domain` CLI flag (default "cluster.local") on the operator binary. - Threaded through the existing `redisfailover.Config` struct, the factory, and `NewRedisFailoverKubeClient`, which now takes the cluster domain as a constructor argument and stores it on the client. - `generateRedisCertificate` and `redisCertificateSANs` accept the cluster domain and template the `.svc.<domain>` FQDN SAN entries accordingly. An empty value falls back to "cluster.local" so deployments that never set the flag keep working. Tests: - All `NewRedisFailoverKubeClient` test callers updated to pass the default "cluster.local" — purely mechanical. - New TestEnsureRedisCertificateUsesConfiguredClusterDomain asserts that with --cluster-domain=cozy.local the FQDN SANs use ".cozy.local" and that the default ".cluster.local" form is NOT silently added in addition (which would mask SAN-mismatch bugs). Signed-off-by: Arsolitt <[email protected]>
1 parent d6ee49a commit 6e4b262

7 files changed

Lines changed: 142 additions & 56 deletions

File tree

‎cmd/utils/flags.go‎

Lines changed: 4 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -23,6 +23,7 @@ type CMDFlags struct {
2323
K8sQueriesBurstable int
2424
Concurrency int
2525
LogLevel string
26+
ClusterDomain string
2627
}
2728

2829
// Init initializes and parse the flags
@@ -40,6 +41,8 @@ func (c *CMDFlags) Init() {
4041
// reference: https://github.com/spotahome/kooper/blob/master/controller/controller.go#L89
4142
flag.IntVar(&c.Concurrency, "concurrency", 3, "Number of conccurent workers meant to process events")
4243
flag.StringVar(&c.LogLevel, "log-level", "info", "set log level")
44+
flag.StringVar(&c.ClusterDomain, "cluster-domain", "cluster.local",
45+
"Kubernetes cluster DNS suffix used to template the cert-manager Certificate SAN list (e.g. cluster.local, cozy.local)")
4346
// Parse flags
4447
flag.Parse()
4548

@@ -55,5 +58,6 @@ func (c *CMDFlags) ToRedisOperatorConfig() redisfailover.Config {
5558
MetricsPath: c.MetricsPath,
5659
Concurrency: c.Concurrency,
5760
SupportedNamespacesRegex: c.SupportedNamespacesRegex,
61+
ClusterDomain: c.ClusterDomain,
5862
}
5963
}

‎operator/redisfailover/config.go‎

Lines changed: 11 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1,9 +1,20 @@
11
package redisfailover
22

3+
// DefaultClusterDomain is the SAN suffix used when --cluster-domain is
4+
// not supplied. cluster.local is the upstream Kubernetes default and
5+
// keeps the operator's behaviour backwards-compatible.
6+
const DefaultClusterDomain = "cluster.local"
7+
38
// Config is the configuration for the redis operator.
49
type Config struct {
510
ListenAddress string
611
MetricsPath string
712
Concurrency int
813
SupportedNamespacesRegex string
14+
// ClusterDomain is the cluster's DNS suffix (e.g. "cluster.local",
15+
// "cozy.local"). It is used to template the `*.svc.<domain>` SAN
16+
// entries on the cert-manager Certificate so that TLS verification
17+
// succeeds on clusters running a non-default --cluster-domain.
18+
// Empty falls back to DefaultClusterDomain.
19+
ClusterDomain string
920
}

‎operator/redisfailover/factory.go‎

Lines changed: 5 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -32,7 +32,11 @@ const (
3232
// to create redis failovers.
3333
func New(cfg Config, k8sService k8s.Services, k8sClient kubernetes.Interface, lockNamespace string, redisClient redis.Client, kooperMetricsRecorder metrics.Recorder, logger log.Logger) (controller.Controller, error) {
3434
// Create internal services.
35-
rfService := rfservice.NewRedisFailoverKubeClient(k8sService, logger, kooperMetricsRecorder)
35+
clusterDomain := cfg.ClusterDomain
36+
if clusterDomain == "" {
37+
clusterDomain = DefaultClusterDomain
38+
}
39+
rfService := rfservice.NewRedisFailoverKubeClient(k8sService, logger, kooperMetricsRecorder, clusterDomain)
3640
rfChecker := rfservice.NewRedisFailoverChecker(k8sService, redisClient, logger, kooperMetricsRecorder)
3741
rfHealer := rfservice.NewRedisFailoverHealer(k8sService, redisClient, logger)
3842

‎operator/redisfailover/service/client.go‎

Lines changed: 17 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -33,14 +33,26 @@ type RedisFailoverKubeClient struct {
3333
K8SService k8s.Services
3434
logger log.Logger
3535
metricsClient metrics.Recorder
36-
}
37-
38-
// NewRedisFailoverKubeClient creates a new RedisFailoverKubeClient
39-
func NewRedisFailoverKubeClient(k8sService k8s.Services, logger log.Logger, metricsClient metrics.Recorder) *RedisFailoverKubeClient {
36+
// clusterDomain is the cluster's DNS suffix (e.g. "cluster.local",
37+
// "cozy.local") used to template the FQDN SANs on the cert-manager
38+
// Certificate. Empty falls back to "cluster.local" so existing
39+
// deployments that never set --cluster-domain keep working.
40+
clusterDomain string
41+
}
42+
43+
// NewRedisFailoverKubeClient creates a new RedisFailoverKubeClient.
44+
// clusterDomain controls the *.svc.<domain> SAN entries on the
45+
// generated cert-manager Certificate; pass an empty string to fall
46+
// back to the upstream Kubernetes default ("cluster.local").
47+
func NewRedisFailoverKubeClient(k8sService k8s.Services, logger log.Logger, metricsClient metrics.Recorder, clusterDomain string) *RedisFailoverKubeClient {
48+
if clusterDomain == "" {
49+
clusterDomain = "cluster.local"
50+
}
4051
return &RedisFailoverKubeClient{
4152
K8SService: k8sService,
4253
logger: logger,
4354
metricsClient: metricsClient,
55+
clusterDomain: clusterDomain,
4456
}
4557
}
4658

@@ -157,7 +169,7 @@ func (r *RedisFailoverKubeClient) EnsureRedisCertificate(rf *redisfailoverv1.Red
157169
if !TLSEnabled(rf) || rf.Spec.TLS.CertManager == nil {
158170
return nil
159171
}
160-
cert := generateRedisCertificate(rf, labels, ownerRefs)
172+
cert := generateRedisCertificate(rf, labels, ownerRefs, r.clusterDomain)
161173
err := r.K8SService.CreateOrUpdateCertificate(rf.Namespace, cert)
162174
r.setEnsureOperationMetrics(cert.Namespace, cert.Name, "Certificate", rf.Name, err)
163175
return err

‎operator/redisfailover/service/generator.go‎

Lines changed: 16 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -103,12 +103,12 @@ func redisCLITLSFlags(rf *redisfailoverv1.RedisFailover) string {
103103
// Pod IPs are still not added: they are unstable, and the operator
104104
// uses ServerName override in tls.Config to validate pod-IP-targeted
105105
// dials against the headless DNS SAN instead.
106-
func generateRedisCertificate(rf *redisfailoverv1.RedisFailover, labels map[string]string, ownerRefs []metav1.OwnerReference) *cmapi.Certificate {
106+
func generateRedisCertificate(rf *redisfailoverv1.RedisFailover, labels map[string]string, ownerRefs []metav1.OwnerReference, clusterDomain string) *cmapi.Certificate {
107107
name := GetTLSCertificateName(rf)
108108
secretName := GetTLSSecretName(rf)
109109
cm := rf.Spec.TLS.CertManager
110110

111-
dnsNames, ipAddresses := redisCertificateSANs(rf)
111+
dnsNames, ipAddresses := redisCertificateSANs(rf, clusterDomain)
112112
for _, san := range cm.ExtraSANs {
113113
if ip := net.ParseIP(san); ip != nil {
114114
ipAddresses = append(ipAddresses, ip.String())
@@ -156,7 +156,14 @@ func generateRedisCertificate(rf *redisfailoverv1.RedisFailover, labels map[stri
156156
// in-pod self-dials (liveness probes via -h localhost, the
157157
// redis_exporter sidecar via 127.0.0.1, the sentinel monitor target
158158
// 127.0.0.1) verify cleanly against the same cert.
159-
func redisCertificateSANs(rf *redisfailoverv1.RedisFailover) (dnsNames, ipAddresses []string) {
159+
//
160+
// clusterDomain is the cluster's DNS suffix (e.g. "cluster.local",
161+
// "cozy.local"). An empty value falls back to "cluster.local" so
162+
// existing deployments that never set --cluster-domain keep working.
163+
func redisCertificateSANs(rf *redisfailoverv1.RedisFailover, clusterDomain string) (dnsNames, ipAddresses []string) {
164+
if clusterDomain == "" {
165+
clusterDomain = "cluster.local"
166+
}
160167
ns := rf.Namespace
161168

162169
for _, svc := range []string{
@@ -169,19 +176,20 @@ func redisCertificateSANs(rf *redisfailoverv1.RedisFailover) (dnsNames, ipAddres
169176
svc,
170177
fmt.Sprintf("%s.%s", svc, ns),
171178
fmt.Sprintf("%s.%s.svc", svc, ns),
172-
fmt.Sprintf("%s.%s.svc.cluster.local", svc, ns),
179+
fmt.Sprintf("%s.%s.svc.%s", svc, ns, clusterDomain),
173180
)
174181
}
175182

176-
// Headless service has per-pod DNS records: <pod>.<headless>.<ns>.svc.cluster.local
177-
// We don't know pod count up front; cover the wildcard so any
178-
// replica resolves correctly.
183+
// Headless service has per-pod DNS records:
184+
// <pod>.<headless>.<ns>.svc.<cluster-domain>. We don't know pod
185+
// count up front; cover the wildcard so any replica resolves
186+
// correctly.
179187
headless := GetRedisName(rf)
180188
dnsNames = append(dnsNames,
181189
fmt.Sprintf("*.%s", headless),
182190
fmt.Sprintf("*.%s.%s", headless, ns),
183191
fmt.Sprintf("*.%s.%s.svc", headless, ns),
184-
fmt.Sprintf("*.%s.%s.svc.cluster.local", headless, ns),
192+
fmt.Sprintf("*.%s.%s.svc.%s", headless, ns, clusterDomain),
185193
"localhost",
186194
)
187195

‎operator/redisfailover/service/generator_test.go‎

Lines changed: 27 additions & 27 deletions
Original file line numberDiff line numberDiff line change
@@ -533,7 +533,7 @@ func TestRedisStatefulSetStorageGeneration(t *testing.T) {
533533
generatedStatefulSet = *ss
534534
}).Return(nil)
535535

536-
client := rfservice.NewRedisFailoverKubeClient(ms, log.Dummy, metrics.Dummy)
536+
client := rfservice.NewRedisFailoverKubeClient(ms, log.Dummy, metrics.Dummy, "cluster.local")
537537
err := client.EnsureRedisStatefulset(rf, nil, test.ownerRefs)
538538

539539
// Check that the storage-related fields are as expected
@@ -587,7 +587,7 @@ func TestRedisStatefulSetCommands(t *testing.T) {
587587
gotCommands = ss.Spec.Template.Spec.Containers[0].Command
588588
}).Return(nil)
589589

590-
client := rfservice.NewRedisFailoverKubeClient(ms, log.Dummy, metrics.Dummy)
590+
client := rfservice.NewRedisFailoverKubeClient(ms, log.Dummy, metrics.Dummy, "cluster.local")
591591
err := client.EnsureRedisStatefulset(rf, nil, []metav1.OwnerReference{})
592592

593593
assert.Equal(test.expectedCommands, gotCommands)
@@ -639,7 +639,7 @@ func TestSentinelDeploymentCommands(t *testing.T) {
639639
gotCommands = d.Spec.Template.Spec.Containers[0].Command
640640
}).Return(nil)
641641

642-
client := rfservice.NewRedisFailoverKubeClient(ms, log.Dummy, metrics.Dummy)
642+
client := rfservice.NewRedisFailoverKubeClient(ms, log.Dummy, metrics.Dummy, "cluster.local")
643643
err := client.EnsureSentinelDeployment(rf, nil, []metav1.OwnerReference{})
644644

645645
assert.Equal(test.expectedCommands, gotCommands)
@@ -687,7 +687,7 @@ func TestRedisStatefulSetPodAnnotations(t *testing.T) {
687687
gotPodAnnotations = ss.Spec.Template.ObjectMeta.Annotations
688688
}).Return(nil)
689689

690-
client := rfservice.NewRedisFailoverKubeClient(ms, log.Dummy, metrics.Dummy)
690+
client := rfservice.NewRedisFailoverKubeClient(ms, log.Dummy, metrics.Dummy, "cluster.local")
691691
err := client.EnsureRedisStatefulset(rf, nil, []metav1.OwnerReference{})
692692

693693
assert.Equal(test.expectedPodAnnotations, gotPodAnnotations)
@@ -735,7 +735,7 @@ func TestSentinelDeploymentPodAnnotations(t *testing.T) {
735735
gotPodAnnotations = d.Spec.Template.ObjectMeta.Annotations
736736
}).Return(nil)
737737

738-
client := rfservice.NewRedisFailoverKubeClient(ms, log.Dummy, metrics.Dummy)
738+
client := rfservice.NewRedisFailoverKubeClient(ms, log.Dummy, metrics.Dummy, "cluster.local")
739739
err := client.EnsureSentinelDeployment(rf, nil, []metav1.OwnerReference{})
740740

741741
assert.Equal(test.expectedPodAnnotations, gotPodAnnotations)
@@ -777,7 +777,7 @@ func TestRedisStatefulSetServiceAccountName(t *testing.T) {
777777
gotServiceAccountName = ss.Spec.Template.Spec.ServiceAccountName
778778
}).Return(nil)
779779

780-
client := rfservice.NewRedisFailoverKubeClient(ms, log.Dummy, metrics.Dummy)
780+
client := rfservice.NewRedisFailoverKubeClient(ms, log.Dummy, metrics.Dummy, "cluster.local")
781781
err := client.EnsureRedisStatefulset(rf, nil, []metav1.OwnerReference{})
782782

783783
assert.Equal(test.expectedServiceAccountName, gotServiceAccountName)
@@ -819,7 +819,7 @@ func TestSentinelDeploymentServiceAccountName(t *testing.T) {
819819
gotServiceAccountName = d.Spec.Template.Spec.ServiceAccountName
820820
}).Return(nil)
821821

822-
client := rfservice.NewRedisFailoverKubeClient(ms, log.Dummy, metrics.Dummy)
822+
client := rfservice.NewRedisFailoverKubeClient(ms, log.Dummy, metrics.Dummy, "cluster.local")
823823
err := client.EnsureSentinelDeployment(rf, nil, []metav1.OwnerReference{})
824824

825825
assert.Equal(test.expectedServiceAccountName, gotServiceAccountName)
@@ -1036,7 +1036,7 @@ func TestSentinelService(t *testing.T) {
10361036
generatedService = *s
10371037
}).Return(nil)
10381038

1039-
client := rfservice.NewRedisFailoverKubeClient(ms, log.Dummy, metrics.Dummy)
1039+
client := rfservice.NewRedisFailoverKubeClient(ms, log.Dummy, metrics.Dummy, "cluster.local")
10401040
err := client.EnsureSentinelService(rf, test.rfLabels, []metav1.OwnerReference{{Name: "testing"}})
10411041

10421042
assert.Equal(test.expectedService, generatedService)
@@ -1284,7 +1284,7 @@ func TestRedisService(t *testing.T) {
12841284
generatedService = *s
12851285
}).Return(nil)
12861286

1287-
client := rfservice.NewRedisFailoverKubeClient(ms, log.Dummy, metrics.Dummy)
1287+
client := rfservice.NewRedisFailoverKubeClient(ms, log.Dummy, metrics.Dummy, "cluster.local")
12881288
err := client.EnsureRedisService(rf, test.rfLabels, []metav1.OwnerReference{{Name: "testing"}})
12891289

12901290
assert.Equal(test.expectedService, generatedService)
@@ -1524,7 +1524,7 @@ func TestRedisMasterService(t *testing.T) {
15241524
generatedMasterService = *s
15251525
}).Return(nil)
15261526

1527-
client := rfservice.NewRedisFailoverKubeClient(ms, log.Dummy, metrics.Dummy)
1527+
client := rfservice.NewRedisFailoverKubeClient(ms, log.Dummy, metrics.Dummy, "cluster.local")
15281528
err := client.EnsureRedisMasterService(rf, test.rfLabels, []metav1.OwnerReference{{Name: "testing"}})
15291529

15301530
assert.Equal(test.expectedService, generatedMasterService)
@@ -1764,7 +1764,7 @@ func TestRedisSlaveService(t *testing.T) {
17641764
generatedSlaveService = *s
17651765
}).Return(nil)
17661766

1767-
client := rfservice.NewRedisFailoverKubeClient(ms, log.Dummy, metrics.Dummy)
1767+
client := rfservice.NewRedisFailoverKubeClient(ms, log.Dummy, metrics.Dummy, "cluster.local")
17681768
err := client.EnsureRedisSlaveService(rf, test.rfLabels, []metav1.OwnerReference{{Name: "testing"}})
17691769

17701770
assert.Equal(test.expectedService, generatedSlaveService)
@@ -1813,7 +1813,7 @@ func TestRedisHostNetworkAndDnsPolicy(t *testing.T) {
18131813
actualDnsPolicy = ss.Spec.Template.Spec.DNSPolicy
18141814
}).Return(nil)
18151815

1816-
client := rfservice.NewRedisFailoverKubeClient(ms, log.Dummy, metrics.Dummy)
1816+
client := rfservice.NewRedisFailoverKubeClient(ms, log.Dummy, metrics.Dummy, "cluster.local")
18171817
err := client.EnsureRedisStatefulset(rf, nil, []metav1.OwnerReference{})
18181818
assert.NoError(err)
18191819

@@ -1862,7 +1862,7 @@ func TestSentinelHostNetworkAndDnsPolicy(t *testing.T) {
18621862
actualDnsPolicy = d.Spec.Template.Spec.DNSPolicy
18631863
}).Return(nil)
18641864

1865-
client := rfservice.NewRedisFailoverKubeClient(ms, log.Dummy, metrics.Dummy)
1865+
client := rfservice.NewRedisFailoverKubeClient(ms, log.Dummy, metrics.Dummy, "cluster.local")
18661866
err := client.EnsureSentinelDeployment(rf, nil, []metav1.OwnerReference{})
18671867
assert.NoError(err)
18681868

@@ -1912,7 +1912,7 @@ func TestRedisImagePullPolicy(t *testing.T) {
19121912
exporterPolicy = ss.Spec.Template.Spec.Containers[1].ImagePullPolicy
19131913
}).Return(nil)
19141914

1915-
client := rfservice.NewRedisFailoverKubeClient(ms, log.Dummy, metrics.Dummy)
1915+
client := rfservice.NewRedisFailoverKubeClient(ms, log.Dummy, metrics.Dummy, "cluster.local")
19161916
err := client.EnsureRedisStatefulset(rf, nil, []metav1.OwnerReference{})
19171917

19181918
assert.NoError(err)
@@ -1958,7 +1958,7 @@ func TestSentinelImagePullPolicy(t *testing.T) {
19581958
configPolicy = d.Spec.Template.Spec.InitContainers[0].ImagePullPolicy
19591959
}).Return(nil)
19601960

1961-
client := rfservice.NewRedisFailoverKubeClient(ms, log.Dummy, metrics.Dummy)
1961+
client := rfservice.NewRedisFailoverKubeClient(ms, log.Dummy, metrics.Dummy, "cluster.local")
19621962
err := client.EnsureSentinelDeployment(rf, nil, []metav1.OwnerReference{})
19631963

19641964
assert.NoError(err)
@@ -2033,7 +2033,7 @@ func TestRedisExtraVolumeMounts(t *testing.T) {
20332033
extraVolumeMount = s.Spec.Template.Spec.Containers[0].VolumeMounts[4]
20342034
}).Return(nil)
20352035

2036-
client := rfservice.NewRedisFailoverKubeClient(ms, log.Dummy, metrics.Dummy)
2036+
client := rfservice.NewRedisFailoverKubeClient(ms, log.Dummy, metrics.Dummy, "cluster.local")
20372037
err := client.EnsureRedisStatefulset(rf, nil, []metav1.OwnerReference{})
20382038

20392039
assert.NoError(err)
@@ -2108,7 +2108,7 @@ func TestSentinelExtraVolumeMounts(t *testing.T) {
21082108
extraVolumeMount = d.Spec.Template.Spec.Containers[0].VolumeMounts[1]
21092109
}).Return(nil)
21102110

2111-
client := rfservice.NewRedisFailoverKubeClient(ms, log.Dummy, metrics.Dummy)
2111+
client := rfservice.NewRedisFailoverKubeClient(ms, log.Dummy, metrics.Dummy, "cluster.local")
21122112
err := client.EnsureSentinelDeployment(rf, nil, []metav1.OwnerReference{})
21132113

21142114
assert.NoError(err)
@@ -2164,7 +2164,7 @@ func TestCustomPort(t *testing.T) {
21642164
port = s.Spec.Template.Spec.Containers[0].Ports[0]
21652165
}).Return(nil)
21662166

2167-
client := rfservice.NewRedisFailoverKubeClient(ms, log.Dummy, metrics.Dummy)
2167+
client := rfservice.NewRedisFailoverKubeClient(ms, log.Dummy, metrics.Dummy, "cluster.local")
21682168
err := client.EnsureRedisStatefulset(rf, nil, []metav1.OwnerReference{})
21692169

21702170
assert.NoError(err)
@@ -2246,7 +2246,7 @@ func TestRedisEnv(t *testing.T) {
22462246
env = s.Spec.Template.Spec.Containers[0].Env
22472247
}).Return(nil)
22482248

2249-
client := rfservice.NewRedisFailoverKubeClient(ms, log.Dummy, metrics.Dummy)
2249+
client := rfservice.NewRedisFailoverKubeClient(ms, log.Dummy, metrics.Dummy, "cluster.local")
22502250
err := client.EnsureRedisStatefulset(rf, nil, []metav1.OwnerReference{})
22512251

22522252
assert.NoError(err)
@@ -2298,7 +2298,7 @@ func TestRedisStartupProbe(t *testing.T) {
22982298
startupVolumeMounts = s.Spec.Template.Spec.Containers[0].VolumeMounts
22992299
}).Return(nil)
23002300

2301-
client := rfservice.NewRedisFailoverKubeClient(ms, log.Dummy, metrics.Dummy)
2301+
client := rfservice.NewRedisFailoverKubeClient(ms, log.Dummy, metrics.Dummy, "cluster.local")
23022302
err := client.EnsureRedisStatefulset(rf, nil, []metav1.OwnerReference{})
23032303

23042304
assert.NoError(err)
@@ -2351,7 +2351,7 @@ func TestSentinelStartupProbe(t *testing.T) {
23512351
startupVolumeMounts = d.Spec.Template.Spec.Containers[0].VolumeMounts
23522352
}).Return(nil)
23532353

2354-
client := rfservice.NewRedisFailoverKubeClient(ms, log.Dummy, metrics.Dummy)
2354+
client := rfservice.NewRedisFailoverKubeClient(ms, log.Dummy, metrics.Dummy, "cluster.local")
23552355
err := client.EnsureSentinelDeployment(rf, nil, []metav1.OwnerReference{})
23562356

23572357
assert.NoError(err)
@@ -2434,7 +2434,7 @@ func TestRedisCustomLivenessProbe(t *testing.T) {
24342434
livenessProbe = s.Spec.Template.Spec.Containers[0].LivenessProbe
24352435
}).Return(nil)
24362436

2437-
client := rfservice.NewRedisFailoverKubeClient(ms, log.Dummy, metrics.Dummy)
2437+
client := rfservice.NewRedisFailoverKubeClient(ms, log.Dummy, metrics.Dummy, "cluster.local")
24382438
err := client.EnsureRedisStatefulset(rf, nil, []metav1.OwnerReference{})
24392439

24402440
assert.NoError(err)
@@ -2513,7 +2513,7 @@ func TestSentinelCustomLivenessProbe(t *testing.T) {
25132513
livenessProbe = d.Spec.Template.Spec.Containers[0].LivenessProbe
25142514
}).Return(nil)
25152515

2516-
client := rfservice.NewRedisFailoverKubeClient(ms, log.Dummy, metrics.Dummy)
2516+
client := rfservice.NewRedisFailoverKubeClient(ms, log.Dummy, metrics.Dummy, "cluster.local")
25172517
err := client.EnsureSentinelDeployment(rf, nil, []metav1.OwnerReference{})
25182518

25192519
assert.NoError(err)
@@ -2580,7 +2580,7 @@ func TestRedisCustomReadinessProbe(t *testing.T) {
25802580
readinessProbe = s.Spec.Template.Spec.Containers[0].ReadinessProbe
25812581
}).Return(nil)
25822582

2583-
client := rfservice.NewRedisFailoverKubeClient(ms, log.Dummy, metrics.Dummy)
2583+
client := rfservice.NewRedisFailoverKubeClient(ms, log.Dummy, metrics.Dummy, "cluster.local")
25842584
err := client.EnsureRedisStatefulset(rf, nil, []metav1.OwnerReference{})
25852585

25862586
assert.NoError(err)
@@ -2659,7 +2659,7 @@ func TestSentinelCustomReadinessProbe(t *testing.T) {
26592659
readinessProbe = d.Spec.Template.Spec.Containers[0].ReadinessProbe
26602660
}).Return(nil)
26612661

2662-
client := rfservice.NewRedisFailoverKubeClient(ms, log.Dummy, metrics.Dummy)
2662+
client := rfservice.NewRedisFailoverKubeClient(ms, log.Dummy, metrics.Dummy, "cluster.local")
26632663
err := client.EnsureSentinelDeployment(rf, nil, []metav1.OwnerReference{})
26642664

26652665
assert.NoError(err)
@@ -2718,7 +2718,7 @@ func TestRedisCustomStartupProbe(t *testing.T) {
27182718
startupProbe = s.Spec.Template.Spec.Containers[0].StartupProbe
27192719
}).Return(nil)
27202720

2721-
client := rfservice.NewRedisFailoverKubeClient(ms, log.Dummy, metrics.Dummy)
2721+
client := rfservice.NewRedisFailoverKubeClient(ms, log.Dummy, metrics.Dummy, "cluster.local")
27222722
err := client.EnsureRedisStatefulset(rf, nil, []metav1.OwnerReference{})
27232723

27242724
assert.NoError(err)
@@ -2785,7 +2785,7 @@ func TestSentinelCustomStartupProbe(t *testing.T) {
27852785
startupProbe = d.Spec.Template.Spec.Containers[0].StartupProbe
27862786
}).Return(nil)
27872787

2788-
client := rfservice.NewRedisFailoverKubeClient(ms, log.Dummy, metrics.Dummy)
2788+
client := rfservice.NewRedisFailoverKubeClient(ms, log.Dummy, metrics.Dummy, "cluster.local")
27892789
err := client.EnsureSentinelDeployment(rf, nil, []metav1.OwnerReference{})
27902790

27912791
assert.NoError(err)

0 commit comments

Comments
 (0)