refactor: remove usless options (kubesphere#5671)

refactor: remove useless options

cmd/controller-manager/app/options/options.go

@@ -40,14 +40,12 @@ import (
 	"kubesphere.io/kubesphere/pkg/simple/client/multicluster"
 	"kubesphere.io/kubesphere/pkg/simple/client/network"
 	"kubesphere.io/kubesphere/pkg/simple/client/openpitrix"
-	"kubesphere.io/kubesphere/pkg/simple/client/s3"
 	"kubesphere.io/kubesphere/pkg/simple/client/servicemesh"
 )
 
 type KubeSphereControllerManagerOptions struct {
 	KubernetesOptions     *k8s.KubernetesOptions
 	DevopsOptions         *jenkins.Options
-	S3Options             *s3.Options
 	AuthenticationOptions *authentication.Options
 	LdapOptions           *ldapclient.Options
 	OpenPitrixOptions     *openpitrix.Options
@@ -88,7 +86,6 @@ func NewKubeSphereControllerManagerOptions() *KubeSphereControllerManagerOptions
 	s := &KubeSphereControllerManagerOptions{
 		KubernetesOptions:     k8s.NewKubernetesOptions(),
 		DevopsOptions:         jenkins.NewDevopsOptions(),
-		S3Options:             s3.NewS3Options(),
 		LdapOptions:           ldapclient.NewOptions(),
 		OpenPitrixOptions:     openpitrix.NewOptions(),
 		NetworkOptions:        network.NewNetworkOptions(),
@@ -116,7 +113,6 @@ func (s *KubeSphereControllerManagerOptions) Flags(allControllerNameSelectors []
 
 	s.KubernetesOptions.AddFlags(fss.FlagSet("kubernetes"), s.KubernetesOptions)
 	s.DevopsOptions.AddFlags(fss.FlagSet("devops"), s.DevopsOptions)
-	s.S3Options.AddFlags(fss.FlagSet("s3"), s.S3Options)
 	s.AuthenticationOptions.AddFlags(fss.FlagSet("authentication"), s.AuthenticationOptions)
 	s.LdapOptions.AddFlags(fss.FlagSet("ldap"), s.LdapOptions)
 	s.OpenPitrixOptions.AddFlags(fss.FlagSet("openpitrix"), s.OpenPitrixOptions)
@@ -161,28 +157,27 @@ func (s *KubeSphereControllerManagerOptions) Flags(allControllerNameSelectors []
 }
 
 // Validate Options and Genetic Options
-func (o *KubeSphereControllerManagerOptions) Validate(allControllerNameSelectors []string) []error {
+func (s *KubeSphereControllerManagerOptions) Validate(allControllerNameSelectors []string) []error {
 	var errs []error
-	errs = append(errs, o.DevopsOptions.Validate()...)
-	errs = append(errs, o.KubernetesOptions.Validate()...)
-	errs = append(errs, o.S3Options.Validate()...)
-	errs = append(errs, o.OpenPitrixOptions.Validate()...)
-	errs = append(errs, o.NetworkOptions.Validate()...)
-	errs = append(errs, o.LdapOptions.Validate()...)
-	errs = append(errs, o.MultiClusterOptions.Validate()...)
-	errs = append(errs, o.AlertingOptions.Validate()...)
+	errs = append(errs, s.DevopsOptions.Validate()...)
+	errs = append(errs, s.KubernetesOptions.Validate()...)
+	errs = append(errs, s.OpenPitrixOptions.Validate()...)
+	errs = append(errs, s.NetworkOptions.Validate()...)
+	errs = append(errs, s.LdapOptions.Validate()...)
+	errs = append(errs, s.MultiClusterOptions.Validate()...)
+	errs = append(errs, s.AlertingOptions.Validate()...)
 
 	// genetic option: application-selector
-	if len(o.ApplicationSelector) != 0 {
-		_, err := labels.Parse(o.ApplicationSelector)
+	if len(s.ApplicationSelector) != 0 {
+		_, err := labels.Parse(s.ApplicationSelector)
 		if err != nil {
 			errs = append(errs, err)
 		}
 	}
 
 	// genetic option: controllers, check all selectors are valid
 	allControllersNameSet := sets.New(allControllerNameSelectors...)
-	for _, selector := range o.ControllerGates {
+	for _, selector := range s.ControllerGates {
 		if selector == "*" {
 			continue
 		}
@@ -196,9 +191,9 @@ func (o *KubeSphereControllerManagerOptions) Validate(allControllerNameSelectors
 }
 
 // IsControllerEnabled check if a specified controller enabled or not.
-func (o *KubeSphereControllerManagerOptions) IsControllerEnabled(name string) bool {
+func (s *KubeSphereControllerManagerOptions) IsControllerEnabled(name string) bool {
 	hasStar := false
-	for _, ctrl := range o.ControllerGates {
+	for _, ctrl := range s.ControllerGates {
 		if ctrl == name {
 			return true
 		}
@@ -234,7 +229,6 @@ func (s *KubeSphereControllerManagerOptions) bindLeaderElectionFlags(l *leaderel
 func (s *KubeSphereControllerManagerOptions) MergeConfig(cfg *controllerconfig.Config) {
 	s.KubernetesOptions = cfg.KubernetesOptions
 	s.DevopsOptions = cfg.DevopsOptions
-	s.S3Options = cfg.S3Options
 	s.AuthenticationOptions = cfg.AuthenticationOptions
 	s.LdapOptions = cfg.LdapOptions
 	s.OpenPitrixOptions = cfg.OpenPitrixOptions

cmd/controller-manager/app/server.go

@@ -44,7 +44,6 @@ import (
 	"kubesphere.io/kubesphere/pkg/controller/user"
 	"kubesphere.io/kubesphere/pkg/informers"
 	"kubesphere.io/kubesphere/pkg/simple/client/k8s"
-	"kubesphere.io/kubesphere/pkg/simple/client/s3"
 	"kubesphere.io/kubesphere/pkg/utils/metrics"
 	"kubesphere.io/kubesphere/pkg/utils/term"
 	"kubesphere.io/kubesphere/pkg/version"
@@ -58,7 +57,6 @@ func NewControllerManagerCommand() *cobra.Command {
 		s = &options.KubeSphereControllerManagerOptions{
 			KubernetesOptions:     conf.KubernetesOptions,
 			DevopsOptions:         conf.DevopsOptions,
-			S3Options:             conf.S3Options,
 			AuthenticationOptions: conf.AuthenticationOptions,
 			LdapOptions:           conf.LdapOptions,
 			OpenPitrixOptions:     conf.OpenPitrixOptions,
@@ -170,13 +168,6 @@ func run(s *options.KubeSphereControllerManagerOptions, ctx context.Context) err
 		return err
 	}
 
-	if s.S3Options != nil && len(s.S3Options.Endpoint) != 0 {
-		_, err = s3.NewS3Client(s.S3Options)
-		if err != nil {
-			return fmt.Errorf("failed to connect to s3, please check s3 service status, error: %v", err)
-		}
-	}
-
 	informerFactory := informers.NewInformerFactories(
 		kubernetesClient.Kubernetes(),
 		kubernetesClient.KubeSphere(),

cmd/ks-apiserver/apiserver.go

@@ -17,16 +17,15 @@ limitations under the License.
 package main
 
 import (
-	"log"
+	"os"
+
+	"k8s.io/component-base/cli"
 
 	"kubesphere.io/kubesphere/cmd/ks-apiserver/app"
 )
 
 func main() {
-
 	cmd := app.NewAPIServerCommand()
-
-	if err := cmd.Execute(); err != nil {
-		log.Fatalln(err)
-	}
+	code := cli.Run(cmd)
+	os.Exit(code)
 }

cmd/ks-apiserver/app/options/options.go

@@ -24,6 +24,8 @@ import (
 	"strings"
 	"sync"
 
+	"kubesphere.io/kubesphere/pkg/simple/client/cache"
+
 	"sigs.k8s.io/controller-runtime/pkg/client/apiutil"
 
 	openpitrixv1 "kubesphere.io/kubesphere/pkg/kapis/openpitrix/v1"
@@ -44,16 +46,12 @@ import (
 	genericoptions "kubesphere.io/kubesphere/pkg/server/options"
 	"kubesphere.io/kubesphere/pkg/simple/client/alerting"
 	auditingclient "kubesphere.io/kubesphere/pkg/simple/client/auditing/elasticsearch"
-	"kubesphere.io/kubesphere/pkg/simple/client/cache"
-
 	"kubesphere.io/kubesphere/pkg/simple/client/devops/jenkins"
 	eventsclient "kubesphere.io/kubesphere/pkg/simple/client/events/elasticsearch"
 	"kubesphere.io/kubesphere/pkg/simple/client/k8s"
 	esclient "kubesphere.io/kubesphere/pkg/simple/client/logging/elasticsearch"
 	"kubesphere.io/kubesphere/pkg/simple/client/monitoring/metricsserver"
 	"kubesphere.io/kubesphere/pkg/simple/client/monitoring/prometheus"
-	"kubesphere.io/kubesphere/pkg/simple/client/s3"
-	fakes3 "kubesphere.io/kubesphere/pkg/simple/client/s3/fake"
 	"kubesphere.io/kubesphere/pkg/simple/client/sonarqube"
 )
 
@@ -63,9 +61,6 @@ type ServerRunOptions struct {
 	*apiserverconfig.Config
 	schemeOnce sync.Once
 	DebugMode  bool
-
-	// Enable gops or not.
-	GOPSEnabled bool
 }
 
 func NewServerRunOptions() *ServerRunOptions {
@@ -81,8 +76,6 @@ func NewServerRunOptions() *ServerRunOptions {
 func (s *ServerRunOptions) Flags() (fss cliflag.NamedFlagSets) {
 	fs := fss.FlagSet("generic")
 	fs.BoolVar(&s.DebugMode, "debug", false, "Don't enable this if you don't know what it means.")
-	fs.BoolVar(&s.GOPSEnabled, "gops", false, "Whether to enable gops or not. When enabled this option, "+
-		"ks-apiserver will listen on a random port on 127.0.0.1, then you can use the gops tool to list and diagnose the ks-apiserver currently running.")
 	s.GenericServerRunOptions.AddFlags(fs, s.GenericServerRunOptions)
 	s.KubernetesOptions.AddFlags(fss.FlagSet("kubernetes"), s.KubernetesOptions)
 	s.AuthenticationOptions.AddFlags(fss.FlagSet("authentication"), s.AuthenticationOptions)
@@ -111,8 +104,6 @@ func (s *ServerRunOptions) Flags() (fss cliflag.NamedFlagSets) {
 	return fss
 }
 
-const fakeInterface string = "FAKE"
-
 // NewAPIServer creates an APIServer instance using given options
 func (s *ServerRunOptions) NewAPIServer(stopCh <-chan struct{}) (*apiserver.APIServer, error) {
 	apiServer := &apiserver.APIServer{
@@ -132,41 +123,23 @@ func (s *ServerRunOptions) NewAPIServer(stopCh <-chan struct{}) (*apiserver.APIS
 	if s.MonitoringOptions == nil || len(s.MonitoringOptions.Endpoint) == 0 {
 		return nil, fmt.Errorf("moinitoring service address in configuration MUST not be empty, please check configmap/kubesphere-config in kubesphere-system namespace")
 	} else {
-		monitoringClient, err := prometheus.NewPrometheus(s.MonitoringOptions)
-		if err != nil {
+		if apiServer.MonitoringClient, err = prometheus.NewPrometheus(s.MonitoringOptions); err != nil {
 			return nil, fmt.Errorf("failed to connect to prometheus, please check prometheus status, error: %v", err)
 		}
-		apiServer.MonitoringClient = monitoringClient
 	}
 
 	apiServer.MetricsClient = metricsserver.NewMetricsClient(kubernetesClient.Kubernetes(), s.KubernetesOptions)
 
 	if s.LoggingOptions.Host != "" {
-		loggingClient, err := esclient.NewClient(s.LoggingOptions)
-		if err != nil {
+		if apiServer.LoggingClient, err = esclient.NewClient(s.LoggingOptions); err != nil {
 			return nil, fmt.Errorf("failed to connect to elasticsearch, please check elasticsearch status, error: %v", err)
 		}
-		apiServer.LoggingClient = loggingClient
-	}
-
-	if s.S3Options.Endpoint != "" {
-		if s.S3Options.Endpoint == fakeInterface && s.DebugMode {
-			apiServer.S3Client = fakes3.NewFakeS3()
-		} else {
-			s3Client, err := s3.NewS3Client(s.S3Options)
-			if err != nil {
-				return nil, fmt.Errorf("failed to connect to s3, please check s3 service status, error: %v", err)
-			}
-			apiServer.S3Client = s3Client
-		}
 	}
 
 	if s.DevopsOptions.Host != "" {
-		devopsClient, err := jenkins.NewDevopsClient(s.DevopsOptions)
-		if err != nil {
+		if apiServer.DevopsClient, err = jenkins.NewDevopsClient(s.DevopsOptions); err != nil {
 			return nil, fmt.Errorf("failed to connect to jenkins, please check jenkins status, error: %v", err)
 		}
-		apiServer.DevopsClient = devopsClient
 	}
 
 	if s.SonarQubeOptions.Host != "" {
@@ -177,52 +150,30 @@ func (s *ServerRunOptions) NewAPIServer(stopCh <-chan struct{}) (*apiserver.APIS
 		apiServer.SonarClient = sonarqube.NewSonar(sonarClient.SonarQube())
 	}
 
-	// If debug mode is on or CacheOptions is nil, will create a fake cache.
-	if s.CacheOptions.Type != "" {
-		if s.DebugMode {
-			s.CacheOptions.Type = cache.DefaultCacheType
-		}
-		cacheClient, err := cache.New(s.CacheOptions, stopCh)
-		if err != nil {
-			return nil, fmt.Errorf("failed to create cache, error: %v", err)
-		}
-		apiServer.CacheClient = cacheClient
-	} else {
-		s.CacheOptions = &cache.Options{Type: cache.DefaultCacheType}
-		// fake cache has no error to return
-		cacheClient, _ := cache.New(s.CacheOptions, stopCh)
-		apiServer.CacheClient = cacheClient
-		klog.Warning("ks-apiserver starts without cache provided, it will use in memory cache. " +
-			"This may cause inconsistencies when running ks-apiserver with multiple replicas, and memory leak risk")
+	if apiServer.CacheClient, err = cache.New(s.CacheOptions, stopCh); err != nil {
+		return nil, fmt.Errorf("failed to create cache, error: %v", err)
 	}
 
 	if s.EventsOptions.Host != "" {
-		eventsClient, err := eventsclient.NewClient(s.EventsOptions)
-		if err != nil {
+		if apiServer.EventsClient, err = eventsclient.NewClient(s.EventsOptions); err != nil {
 			return nil, fmt.Errorf("failed to connect to elasticsearch, please check elasticsearch status, error: %v", err)
 		}
-		apiServer.EventsClient = eventsClient
 	}
 
 	if s.AuditingOptions.Host != "" {
-		auditingClient, err := auditingclient.NewClient(s.AuditingOptions)
-		if err != nil {
+		if apiServer.AuditingClient, err = auditingclient.NewClient(s.AuditingOptions); err != nil {
 			return nil, fmt.Errorf("failed to connect to elasticsearch, please check elasticsearch status, error: %v", err)
 		}
-		apiServer.AuditingClient = auditingClient
 	}
 
 	if s.AlertingOptions != nil && (s.AlertingOptions.PrometheusEndpoint != "" || s.AlertingOptions.ThanosRulerEndpoint != "") {
-		alertingClient, err := alerting.NewRuleClient(s.AlertingOptions)
-		if err != nil {
+		if apiServer.AlertingClient, err = alerting.NewRuleClient(s.AlertingOptions); err != nil {
 			return nil, fmt.Errorf("failed to init alerting client: %v", err)
 		}
-		apiServer.AlertingClient = alertingClient
 	}
 
 	if s.Config.MultiClusterOptions.Enable {
-		cc := clusterclient.NewClusterClient(informerFactory.KubeSphereSharedInformerFactory().Cluster().V1alpha1().Clusters())
-		apiServer.ClusterClient = cc
+		apiServer.ClusterClient = clusterclient.NewClusterClient(informerFactory.KubeSphereSharedInformerFactory().Cluster().V1alpha1().Clusters())
 	}
 
 	apiServer.OpenpitrixClient = openpitrixv1.NewOpenpitrixClient(informerFactory, apiServer.KubernetesClient.KubeSphere(), s.OpenPitrixOptions, apiServer.ClusterClient)

cmd/ks-apiserver/app/server.go

@@ -56,7 +56,7 @@ cluster's shared state through which all other components interact.`,
 				return utilerrors.NewAggregate(errs)
 			}
 
-			if s.GOPSEnabled {
+			if s.DebugMode {
 				// Add agent to report additional information such as the current stack trace, Go version, memory stats, etc.
 				// Bind to a random port on address 127.0.0.1.
 				if err := agent.Listen(agent.Options{}); err != nil {

pkg/apiserver/apiserver.go

@@ -107,7 +107,6 @@ import (
 	"kubesphere.io/kubesphere/pkg/simple/client/k8s"
 	"kubesphere.io/kubesphere/pkg/simple/client/logging"
 	"kubesphere.io/kubesphere/pkg/simple/client/monitoring"
-	"kubesphere.io/kubesphere/pkg/simple/client/s3"
 	"kubesphere.io/kubesphere/pkg/simple/client/sonarqube"
 	"kubesphere.io/kubesphere/pkg/utils/clusterclient"
 	"kubesphere.io/kubesphere/pkg/utils/iputil"
@@ -146,8 +145,6 @@ type APIServer struct {
 
 	DevopsClient devops.Interface
 
-	S3Client s3.Interface
-
 	SonarClient sonarqube.SonarInterface
 
 	EventsClient events.Client

pkg/simple/client/cache/cache.go

@@ -39,13 +39,13 @@ type Interface interface {
 	// Set sets the value and living duration of the given key, zero duration means never expire
 	Set(key string, value string, duration time.Duration) error
 
-	// Del deletes the given key, no error returned if the key doesn't exists
+	// Del deletes the given key, no error returned if the key doesn't exist
 	Del(keys ...string) error
 
 	// Exists checks the existence of a give key
 	Exists(keys ...string) (bool, error)
 
-	// Expires updates object's expiration time, return err if key doesn't exist
+	// Expire updates object's expiration time, return err if key doesn't exist
 	Expire(key string, duration time.Duration) error
 }
 
@@ -60,6 +60,10 @@ func New(option *Options, stopCh <-chan struct{}) (Interface, error) {
 		return nil, err
 	}
 
+	if option.Type == TypeInMemoryCache {
+		klog.Warning("In-memory cache will be used, this may cause data inconsistencies when running with multiple replicas.")
+	}
+
 	cache, err := cacheFactories[option.Type].Create(option.Options, stopCh)
 	if err != nil {
 		klog.Errorf("failed to create cache, error: %v", err)

pkg/simple/client/cache/inmemory_cache.go

@@ -32,9 +32,7 @@ import (
 var ErrNoSuchKey = errors.New("no such key")
 
 const (
-	typeInMemoryCache = "InMemoryCache"
-	DefaultCacheType  = typeInMemoryCache
-
+	TypeInMemoryCache    = "InMemoryCache"
 	defaultCleanupPeriod = 2 * time.Hour
 )
 
@@ -176,12 +174,11 @@ type inMemoryCacheFactory struct {
 }
 
 func (sf *inMemoryCacheFactory) Type() string {
-	return typeInMemoryCache
+	return TypeInMemoryCache
 }
 
 func (sf *inMemoryCacheFactory) Create(options options.DynamicOptions, stopCh <-chan struct{}) (Interface, error) {
 	var sOptions InMemoryCacheOptions
-
 	decoder, err := mapstructure.NewDecoder(&mapstructure.DecoderConfig{
 		DecodeHook:       mapstructure.StringToTimeDurationHookFunc(),
 		WeaklyTypedInput: true,

pkg/simple/client/cache/options.go

@@ -31,7 +31,7 @@ type Options struct {
 // because redis is not required for some components
 func NewCacheOptions() *Options {
 	return &Options{
-		Type:    "",
+		Type:    TypeInMemoryCache,
 		Options: map[string]interface{}{},
 	}
 }