fix: ensure that the feature instance is initialized only once

pkg/controllers/etcdcluster/etcdclusters_controller.go

@@ -357,11 +357,6 @@ func (c *ClusterController) handleClusterFeature(cluster *kstonev1alpha1.EtcdClu
 			continue
 		}
 
-		if err = feature.Init(); err != nil {
-			klog.Errorf("failed to init feature %s provider, err is %v", name, err)
-			continue
-		}
-
 		if !feature.Equal(cluster) {
 			klog.V(4).Infof("skip feature %s,no changed, cluster is %s", name, cluster.Name)
 			continue

pkg/controllers/etcdinspection/etcdinspection_controller.go

@@ -248,9 +248,5 @@ func (c *InspectionController) doInspectionTask(etcdinspection *kstonev1alpha1.E
 	if err != nil {
 		return err
 	}
-	if err = feature.Init(); err != nil {
-		klog.Errorf("failed to init feature %s provider, err is %v", inspectionType, err)
-		return err
-	}
 	return feature.Do(etcdinspection)
 }

pkg/featureprovider/feature.go

@@ -24,9 +24,6 @@ import (
 )
 
 type Feature interface {
-	// Init inits the feature provider
-	Init() error
-
 	// Equal checks whether the feature needs to be updated
 	Equal(cluster *v1alpha1.EtcdCluster) bool
 

pkg/featureprovider/providers/backup/backup.go

@@ -30,48 +30,55 @@ const (
 	ProviderName = string(kstoneapiv1.KStoneFeatureBackup)
 )
 
-type Feature struct {
+var (
+	once     sync.Once
+	instance *FeatureBackup
+)
+
+type FeatureBackup struct {
 	name      string
 	backupSvr *backup.Server
-	once      sync.Once
 	ctx       *featureprovider.FeatureContext
 }
 
 func init() {
 	featureprovider.RegisterFeatureFactory(
 		ProviderName,
 		func(ctx *featureprovider.FeatureContext) (featureprovider.Feature, error) {
-			return NewProviderBackup(ctx), nil
+			return initFeatureBackupInstance(ctx)
 		},
 	)
 }
 
-func NewProviderBackup(ctx *featureprovider.FeatureContext) featureprovider.Feature {
-	return &Feature{
-		name: ProviderName,
-		ctx:  ctx,
-	}
-}
-
-func (bak *Feature) Init() error {
+func initFeatureBackupInstance(ctx *featureprovider.FeatureContext) (featureprovider.Feature, error) {
 	var err error
-	bak.once.Do(func() {
-		bak.backupSvr = &backup.Server{
-			Clientbuilder: bak.ctx.Clientbuilder,
+	once.Do(func() {
+		instance = &FeatureBackup{
+			name: ProviderName,
+			ctx:  ctx,
 		}
-		err = bak.backupSvr.Init()
+		err = instance.init()
 	})
+	return instance, err
+}
+
+func (bak *FeatureBackup) init() error {
+	var err error
+	bak.backupSvr = &backup.Server{
+		Clientbuilder: bak.ctx.Clientbuilder,
+	}
+	err = bak.backupSvr.Init()
 	return err
 }
 
-func (bak *Feature) Equal(cluster *kstoneapiv1.EtcdCluster) bool {
+func (bak *FeatureBackup) Equal(cluster *kstoneapiv1.EtcdCluster) bool {
 	return bak.backupSvr.Equal(cluster)
 }
 
-func (bak *Feature) Sync(cluster *kstoneapiv1.EtcdCluster) error {
+func (bak *FeatureBackup) Sync(cluster *kstoneapiv1.EtcdCluster) error {
 	return bak.backupSvr.SyncEtcdBackup(cluster)
 }
 
-func (bak *Feature) Do(inspection *kstoneapiv1.EtcdInspection) error {
+func (bak *FeatureBackup) Do(inspection *kstoneapiv1.EtcdInspection) error {
 	return nil
 }

pkg/featureprovider/providers/consistency/consistency.go

@@ -30,37 +30,44 @@ const (
 	ProviderName = string(kstoneapiv1.KStoneFeatureConsistency)
 )
 
+var (
+	once     sync.Once
+	instance *FeatureConsistency
+)
+
 type FeatureConsistency struct {
 	name       string
 	inspection *inspection.Server
-	once       sync.Once
 	ctx        *featureprovider.FeatureContext
 }
 
 func init() {
 	featureprovider.RegisterFeatureFactory(
 		ProviderName,
 		func(ctx *featureprovider.FeatureContext) (featureprovider.Feature, error) {
-			return NewFeatureConsistency(ctx)
+			return initFeatureConsistencyInstance(ctx)
 		},
 	)
 }
 
-func NewFeatureConsistency(ctx *featureprovider.FeatureContext) (featureprovider.Feature, error) {
-	return &FeatureConsistency{
-		name: ProviderName,
-		ctx:  ctx,
-	}, nil
-}
-
-func (c *FeatureConsistency) Init() error {
+func initFeatureConsistencyInstance(ctx *featureprovider.FeatureContext) (featureprovider.Feature, error) {
 	var err error
-	c.once.Do(func() {
-		c.inspection = &inspection.Server{
-			Clientbuilder: c.ctx.Clientbuilder,
+	once.Do(func() {
+		instance = &FeatureConsistency{
+			name: ProviderName,
+			ctx:  ctx,
 		}
-		err = c.inspection.Init()
+		err = instance.init()
 	})
+	return instance, err
+}
+
+func (c *FeatureConsistency) init() error {
+	var err error
+	c.inspection = &inspection.Server{
+		Clientbuilder: c.ctx.Clientbuilder,
+	}
+	err = c.inspection.Init()
 	return err
 }
 

pkg/featureprovider/providers/healthy/healthy.go

@@ -26,10 +26,14 @@ import (
 	"tkestack.io/kstone/pkg/inspection"
 )
 
+var (
+	once     sync.Once
+	instance *FeatureHealthy
+)
+
 type FeatureHealthy struct {
 	name       string
 	inspection *inspection.Server
-	once       sync.Once
 	ctx        *featureprovider.FeatureContext
 }
 
@@ -41,26 +45,29 @@ func init() {
 	featureprovider.RegisterFeatureFactory(
 		ProviderName,
 		func(ctx *featureprovider.FeatureContext) (featureprovider.Feature, error) {
-			return NewFeatureHealty(ctx)
+			return initFeatureHealthyInstance(ctx)
 		},
 	)
 }
 
-func NewFeatureHealty(ctx *featureprovider.FeatureContext) (featureprovider.Feature, error) {
-	return &FeatureHealthy{
-		name: ProviderName,
-		ctx:  ctx,
-	}, nil
-}
-
-func (c *FeatureHealthy) Init() error {
+func initFeatureHealthyInstance(ctx *featureprovider.FeatureContext) (featureprovider.Feature, error) {
 	var err error
-	c.once.Do(func() {
-		c.inspection = &inspection.Server{
-			Clientbuilder: c.ctx.Clientbuilder,
+	once.Do(func() {
+		instance = &FeatureHealthy{
+			name: ProviderName,
+			ctx:  ctx,
 		}
-		err = c.inspection.Init()
+		err = instance.init()
 	})
+	return instance, err
+}
+
+func (c *FeatureHealthy) init() error {
+	var err error
+	c.inspection = &inspection.Server{
+		Clientbuilder: c.ctx.Clientbuilder,
+	}
+	err = c.inspection.Init()
 	return err
 }
 

pkg/featureprovider/providers/monitor/monitor.go

@@ -26,9 +26,13 @@ import (
 	"tkestack.io/kstone/pkg/monitor"
 )
 
+var (
+	once     sync.Once
+	instance *FeaturePrometheus
+)
+
 type FeaturePrometheus struct {
 	name string
-	once sync.Once
 	prom *monitor.PrometheusMonitor
 	ctx  *featureprovider.FeatureContext
 }
@@ -41,26 +45,29 @@ func init() {
 	featureprovider.RegisterFeatureFactory(
 		ProviderName,
 		func(cfg *featureprovider.FeatureContext) (featureprovider.Feature, error) {
-			return NewEtcdOpsPrometheus(cfg)
+			return initFeaturePrometheusInstance(cfg)
 		},
 	)
 }
 
-func NewEtcdOpsPrometheus(ctx *featureprovider.FeatureContext) (featureprovider.Feature, error) {
-	return &FeaturePrometheus{
-		name: ProviderName,
-		ctx:  ctx,
-	}, nil
-}
-
-func (p *FeaturePrometheus) Init() error {
+func initFeaturePrometheusInstance(ctx *featureprovider.FeatureContext) (featureprovider.Feature, error) {
 	var err error
-	p.once.Do(func() {
-		p.prom = &monitor.PrometheusMonitor{
-			ClientBuilder: p.ctx.Clientbuilder,
+	once.Do(func() {
+		instance = &FeaturePrometheus{
+			name: ProviderName,
+			ctx:  ctx,
 		}
-		err = p.prom.Init()
+		err = instance.init()
 	})
+	return instance, err
+}
+
+func (p *FeaturePrometheus) init() error {
+	var err error
+	p.prom = &monitor.PrometheusMonitor{
+		ClientBuilder: p.ctx.Clientbuilder,
+	}
+	err = p.prom.Init()
 	return err
 }
 

pkg/featureprovider/providers/request/request.go

@@ -30,9 +30,13 @@ const (
 	ProviderName = string(kstoneapiv1.KStoneFeatureRequest)
 )
 
+var (
+	once     sync.Once
+	instance *FeatureRequest
+)
+
 type FeatureRequest struct {
 	name       string
-	once       sync.Once
 	inspection *inspection.Server
 	ctx        *featureprovider.FeatureContext
 }
@@ -41,26 +45,29 @@ func init() {
 	featureprovider.RegisterFeatureFactory(
 		ProviderName,
 		func(ctx *featureprovider.FeatureContext) (featureprovider.Feature, error) {
-			return NewFeatureRequest(ctx)
+			return initFeatureRequestInstance(ctx)
 		},
 	)
 }
 
-func NewFeatureRequest(ctx *featureprovider.FeatureContext) (featureprovider.Feature, error) {
-	return &FeatureRequest{
-		name: ProviderName,
-		ctx:  ctx,
-	}, nil
-}
-
-func (c *FeatureRequest) Init() error {
+func initFeatureRequestInstance(ctx *featureprovider.FeatureContext) (featureprovider.Feature, error) {
 	var err error
-	c.once.Do(func() {
-		c.inspection = &inspection.Server{
-			Clientbuilder: c.ctx.Clientbuilder,
+	once.Do(func() {
+		instance = &FeatureRequest{
+			name: ProviderName,
+			ctx:  ctx,
 		}
-		err = c.inspection.Init()
+		err = instance.init()
 	})
+	return instance, err
+}
+
+func (c *FeatureRequest) init() error {
+	var err error
+	c.inspection = &inspection.Server{
+		Clientbuilder: c.ctx.Clientbuilder,
+	}
+	err = c.inspection.Init()
 	return err
 }