fix code format

cmd/controller-manager/app/controllers.go

@@ -18,10 +18,16 @@ package app
 
 import (
 	"fmt"
+
 	"k8s.io/apimachinery/pkg/labels"
 	"k8s.io/apimachinery/pkg/util/sets"
 	"k8s.io/client-go/tools/cache"
 	"k8s.io/klog"
+	ctrl "sigs.k8s.io/controller-runtime"
+	runtimeclient "sigs.k8s.io/controller-runtime/pkg/client"
+	"sigs.k8s.io/controller-runtime/pkg/manager"
+	"sigs.k8s.io/kubefed/pkg/controller/util"
+
 	"kubesphere.io/kubesphere/cmd/controller-manager/app/options"
 	"kubesphere.io/kubesphere/pkg/controller/application"
 	"kubesphere.io/kubesphere/pkg/controller/helm"
@@ -42,10 +48,6 @@ import (
 	"kubesphere.io/kubesphere/pkg/simple/client/devops/jenkins"
 	ldapclient "kubesphere.io/kubesphere/pkg/simple/client/ldap"
 	"kubesphere.io/kubesphere/pkg/simple/client/s3"
-	ctrl "sigs.k8s.io/controller-runtime"
-	runtimeclient "sigs.k8s.io/controller-runtime/pkg/client"
-	"sigs.k8s.io/controller-runtime/pkg/manager"
-	"sigs.k8s.io/kubefed/pkg/controller/util"
 
 	"kubesphere.io/kubesphere/pkg/controller/storage/snapshotclass"
 
@@ -72,7 +74,7 @@ import (
 	ippoolclient "kubesphere.io/kubesphere/pkg/simple/client/network/ippool"
 )
 
-var allControllers = []string {
+var allControllers = []string{
 	"user",
 	"workspacetemplate",
 	"workspace",
@@ -178,37 +180,37 @@ func addAllControllers(mgr manager.Manager, client k8s.Client, informerFactory i
 			KubeconfigClient:        kubeconfigClient,
 			AuthenticationOptions:   cmOptions.AuthenticationOptions,
 		}
-		addControllerWithSetup(mgr,"user", userController)
+		addControllerWithSetup(mgr, "user", userController)
 	}
 
 	// "workspacetemplate" controller
 	if cmOptions.IsControllerEnabled("workspacetemplate") {
 		workspaceTemplateReconciler := &workspacetemplate.Reconciler{MultiClusterEnabled: cmOptions.MultiClusterOptions.Enable}
-		addControllerWithSetup(mgr,"workspacetemplate", workspaceTemplateReconciler)
+		addControllerWithSetup(mgr, "workspacetemplate", workspaceTemplateReconciler)
 	}
 
 	// "workspace" controller
 	if cmOptions.IsControllerEnabled("workspace") {
 		workspaceReconciler := &workspace.Reconciler{}
-		addControllerWithSetup(mgr,"workspace", workspaceReconciler)
+		addControllerWithSetup(mgr, "workspace", workspaceReconciler)
 	}
 
 	// "workspacerole" controller
 	if cmOptions.IsControllerEnabled("workspacerole") {
 		workspaceRoleReconciler := &workspacerole.Reconciler{MultiClusterEnabled: cmOptions.MultiClusterOptions.Enable}
-		addControllerWithSetup(mgr,"workspacerole", workspaceRoleReconciler)
+		addControllerWithSetup(mgr, "workspacerole", workspaceRoleReconciler)
 	}
 
 	// "workspacerolebinding" controller
 	if cmOptions.IsControllerEnabled("workspacerolebinding") {
 		workspaceRoleBindingReconciler := &workspacerolebinding.Reconciler{MultiClusterEnabled: cmOptions.MultiClusterOptions.Enable}
-		addControllerWithSetup(mgr,"workspacerolebinding", workspaceRoleBindingReconciler)
+		addControllerWithSetup(mgr, "workspacerolebinding", workspaceRoleBindingReconciler)
 	}
 
 	// "namespace" controller
 	if cmOptions.IsControllerEnabled("namespace") {
 		namespaceReconciler := &namespace.Reconciler{}
-		addControllerWithSetup(mgr,"namespace", namespaceReconciler)
+		addControllerWithSetup(mgr, "namespace", namespaceReconciler)
 	}
 
 	// "helmrepo" controller
@@ -239,29 +241,29 @@ func addAllControllers(mgr manager.Manager, client k8s.Client, informerFactory i
 		// "helmapplicationversion" controller
 		if cmOptions.IsControllerEnabled("helmapplicationversion") {
 			reconcileHelmAppVersion := (&helmapplication.ReconcileHelmApplicationVersion{})
-			addControllerWithSetup(mgr, "helmapplicationversion",reconcileHelmAppVersion)
+			addControllerWithSetup(mgr, "helmapplicationversion", reconcileHelmAppVersion)
 		}
 	}
 
 	// "helmrelease" controller
 	if cmOptions.IsControllerEnabled("helmrelease") {
 		reconcileHelmRelease := &helmrelease.ReconcileHelmRelease{
-					// nil interface is valid value.
+			// nil interface is valid value.
-					StorageClient:      opS3Client,
+			StorageClient:      opS3Client,
-					KsFactory:          informerFactory.KubeSphereSharedInformerFactory(),
+			KsFactory:          informerFactory.KubeSphereSharedInformerFactory(),
-					MultiClusterEnable: cmOptions.MultiClusterOptions.Enable,
+			MultiClusterEnable: cmOptions.MultiClusterOptions.Enable,
-					WaitTime:           cmOptions.OpenPitrixOptions.ReleaseControllerOptions.WaitTime,
+			WaitTime:           cmOptions.OpenPitrixOptions.ReleaseControllerOptions.WaitTime,
-					MaxConcurrent:      cmOptions.OpenPitrixOptions.ReleaseControllerOptions.MaxConcurrent,
+			MaxConcurrent:      cmOptions.OpenPitrixOptions.ReleaseControllerOptions.MaxConcurrent,
-					StopChan:           stopCh,
+			StopChan:           stopCh,
-				}
+		}
-		addControllerWithSetup(mgr, "helmrelease",reconcileHelmRelease)
+		addControllerWithSetup(mgr, "helmrelease", reconcileHelmRelease)
 	}
 
 	// "helm" controller
 	if cmOptions.IsControllerEnabled("helm") {
 		if !cmOptions.GatewayOptions.IsEmpty() {
 			helmReconciler := &helm.Reconciler{GatewayOptions: cmOptions.GatewayOptions}
-			addControllerWithSetup(mgr, "helm",helmReconciler)
+			addControllerWithSetup(mgr, "helm", helmReconciler)
 		}
 	}
 
@@ -274,21 +276,21 @@ func addAllControllers(mgr manager.Manager, client k8s.Client, informerFactory i
 			Mapper:              mgr.GetRESTMapper(),
 			ApplicationSelector: selector,
 		}
-		addControllerWithSetup(mgr, "application",applicationReconciler)
+		addControllerWithSetup(mgr, "application", applicationReconciler)
 	}
 
 	// "serviceaccount" controller
 	if cmOptions.IsControllerEnabled("serviceaccount") {
 		saReconciler := &serviceaccount.Reconciler{}
-		addControllerWithSetup(mgr, "serviceaccount",saReconciler)
+		addControllerWithSetup(mgr, "serviceaccount", saReconciler)
 	}
 
 	// "resourcequota" controller
 	if cmOptions.IsControllerEnabled("resourcequota") {
 		resourceQuotaReconciler := &quota.Reconciler{
 			MaxConcurrentReconciles: quota.DefaultMaxConcurrentReconciles,
-			ResyncPeriod: quota.DefaultResyncPeriod,
+			ResyncPeriod:            quota.DefaultResyncPeriod,
-			InformerFactory: informerFactory.KubernetesSharedInformerFactory(),
+			InformerFactory:         informerFactory.KubernetesSharedInformerFactory(),
 		}
 		addControllerWithSetup(mgr, "resourcequota", resourceQuotaReconciler)
 	}
@@ -516,7 +518,6 @@ func addAllControllers(mgr manager.Manager, client k8s.Client, informerFactory i
 	return nil
 }
 
-
 var addSuccessfullyControllers = sets.NewString()
 
 type setupableController interface {

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

@@ -19,10 +19,11 @@ package options
 import (
 	"flag"
 	"fmt"
-	"k8s.io/apimachinery/pkg/util/sets"
 	"strings"
 	"time"
 
+	"k8s.io/apimachinery/pkg/util/sets"
+
 	"kubesphere.io/kubesphere/pkg/apiserver/authentication"
 
 	"k8s.io/apimachinery/pkg/labels"
@@ -190,7 +191,7 @@ func (o *KubeSphereControllerManagerOptions) IsControllerEnabled(name string) bo
 		if ctrl == name {
 			return true
 		}
-		if ctrl == "-" + name {
+		if ctrl == "-"+name {
 			return false
 		}
 		if ctrl == "*" {
@@ -216,4 +217,3 @@ func (s *KubeSphereControllerManagerOptions) bindLeaderElectionFlags(l *leaderel
 		"The duration the clients should wait between attempting acquisition and renewal "+
 		"of a leadership. This is only applicable if leader election is enabled.")
 }
-

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

@@ -1,59 +1,60 @@
 package options
 
 import (
-	"github.com/stretchr/testify/assert"
 	"testing"
+
+	"github.com/stretchr/testify/assert"
 )
 
 // ref: https://github.com/kubernetes/kubernetes/blob/master/staging/src/k8s.io/controller-manager/app/helper_test.go
 func TestIsControllerEnabled(t *testing.T) {
 	testcases := []struct {
-		name string
+		name            string
-		controllerName string
+		controllerName  string
 		controllerFlags []string
-		expected bool
+		expected        bool
 	}{
 		{
-			name:                         "on by name",
+			name:            "on by name",
-			controllerName:               "bravo",
+			controllerName:  "bravo",
-			controllerFlags:              []string{"alpha", "bravo", "-charlie"},
+			controllerFlags: []string{"alpha", "bravo", "-charlie"},
-			expected:                     true,
+			expected:        true,
 		},
 		{
-			name:                         "off by name",
+			name:            "off by name",
-			controllerName:               "charlie",
+			controllerName:  "charlie",
-			controllerFlags:              []string{"alpha", "bravo", "-charlie"},
+			controllerFlags: []string{"alpha", "bravo", "-charlie"},
-			expected:                     false,
+			expected:        false,
 		},
 		{
-			name:                         "on by default",
+			name:            "on by default",
-			controllerName:               "alpha",
+			controllerName:  "alpha",
-			controllerFlags:              []string{"*"},
+			controllerFlags: []string{"*"},
-			expected:                     true,
+			expected:        true,
 		},
 		{
-			name:                         "on by star, not off by name",
+			name:            "on by star, not off by name",
-			controllerName:               "alpha",
+			controllerName:  "alpha",
-			controllerFlags:              []string{"*", "-charlie"},
+			controllerFlags: []string{"*", "-charlie"},
-			expected:                     true,
+			expected:        true,
 		},
 		{
-			name:                         "off by name with star",
+			name:            "off by name with star",
-			controllerName:               "charlie",
+			controllerName:  "charlie",
-			controllerFlags:              []string{"*", "-charlie"},
+			controllerFlags: []string{"*", "-charlie"},
-			expected:                     false,
+			expected:        false,
 		},
 		{
-			name:                         "off then on",
+			name:            "off then on",
-			controllerName:               "alpha",
+			controllerName:  "alpha",
-			controllerFlags:              []string{"-alpha", "alpha"},
+			controllerFlags: []string{"-alpha", "alpha"},
-			expected:                     false,
+			expected:        false,
 		},
 		{
-			name:                         "on then off",
+			name:            "on then off",
-			controllerName:               "alpha",
+			controllerName:  "alpha",
-			controllerFlags:              []string{"alpha", "-alpha"},
+			controllerFlags: []string{"alpha", "-alpha"},
-			expected:                     true,
+			expected:        true,
 		},
 	}
 

pkg/controller/openpitrix/helmcategory/helm_category_controller.go

@@ -18,9 +18,10 @@ package helmcategory
 
 import (
 	"context"
-	ctrl "sigs.k8s.io/controller-runtime"
 	"time"
 
+	ctrl "sigs.k8s.io/controller-runtime"
+
 	"k8s.io/apimachinery/pkg/api/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/types"

pkg/controller/openpitrix/helmrepo/helm_repo_controller.go

@@ -19,9 +19,10 @@ package helmrepo
 import (
 	"context"
 	"math"
-	ctrl "sigs.k8s.io/controller-runtime"
 	"time"
 
+	ctrl "sigs.k8s.io/controller-runtime"
+
 	"k8s.io/apimachinery/pkg/api/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime"

pkg/controller/quota/resourcequota_controller.go

@@ -68,17 +68,17 @@ const (
 // Reconciler reconciles a Workspace object
 type Reconciler struct {
 	client.Client
-	logger                  logr.Logger
+	logger   logr.Logger
-	recorder                record.EventRecorder
+	recorder record.EventRecorder
 	// Knows how to calculate usage
 	registry quotav1.Registry
 
 	MaxConcurrentReconciles int
 	// Controls full recalculation of quota usage
-	ResyncPeriod time.Duration
+	ResyncPeriod    time.Duration
 	InformerFactory k8sinformers.SharedInformerFactory
 
-	scheme       *runtime.Scheme
+	scheme *runtime.Scheme
 }
 
 func (r *Reconciler) SetupWithManager(mgr ctrl.Manager) error {