Fix: initialize kube config multiple times (#3984)

* Fix: initialize kube config multiple times

Signed-off-by: barnettZQG <barnett.zqg@gmail.com>

* Fix: e2e test case

Signed-off-by: barnettZQG <barnett.zqg@gmail.com>

cmd/apiserver/main.go

@@ -109,19 +109,13 @@ type Server struct {
 func (s *Server) run(ctx context.Context, errChan chan error) error {
 	log.Logger.Infof("KubeVela information: version: %v, gitRevision: %v", version.VelaVersion, version.GitRevision)
 
-	server, err := apiserver.New(s.serverConfig)
-	if err != nil {
-		return fmt.Errorf("create apiserver failed : %w ", err)
-	}
+	server := apiserver.New(s.serverConfig)
 
 	return server.Run(ctx, errChan)
 }
 
 func (s *Server) buildSwagger() (*spec.Swagger, error) {
-	server, err := apiserver.New(s.serverConfig)
-	if err != nil {
-		return nil, err
-	}
+	server := apiserver.New(s.serverConfig)
 	config, err := server.BuildRestfulConfig()
 	if err != nil {
 		return nil, err

pkg/apiserver/domain/service/project.go

@@ -363,6 +363,12 @@ func (p *projectServiceImpl) UpdateProject(ctx context.Context, projectName stri
 			}
 			return nil, err
 		}
+		if _, err := p.AddProjectUser(ctx, projectName, apisv1.AddProjectUserRequest{
+			UserName:  req.Owner,
+			UserRoles: []string{"project-admin"},
+		}); err != nil && !errors.Is(err, bcode.ErrProjectUserExist) {
+			return nil, err
+		}
 		project.Owner = req.Owner
 	}
 	err = p.Store.Put(ctx, project)

pkg/apiserver/domain/service/project_test.go

@@ -189,6 +189,27 @@ var _ = Describe("Test project service functions", func() {
 		Expect(base.Description).Should(BeEquivalentTo("Change description"))
 		Expect(base.Owner.Alias).Should(BeEquivalentTo("Administrator"))
 
+		user := &model.User{
+			Name:     "admin-2",
+			Alias:    "Administrator2",
+			Password: "ddddd",
+			Disabled: false,
+		}
+		err = projectService.Store.Add(context.TODO(), user)
+		Expect(err).Should(BeNil())
+		base, err = projectService.UpdateProject(context.TODO(), "test-project", apisv1.UpdateProjectRequest{
+			Alias:       "Change alias",
+			Description: "Change description",
+			Owner:       "admin-2",
+		})
+		Expect(err).Should(BeNil())
+		Expect(base.Alias).Should(BeEquivalentTo("Change alias"))
+		Expect(base.Description).Should(BeEquivalentTo("Change description"))
+		Expect(base.Owner.Alias).Should(BeEquivalentTo("Administrator2"))
+		res, err := projectService.ListProjectUser(context.TODO(), "test-project", 0, 0)
+		Expect(err).Should(BeNil())
+		Expect(res.Total).Should(Equal(int64(2)))
+
 		_, err = projectService.UpdateProject(context.TODO(), "test-project", apisv1.UpdateProjectRequest{
 			Alias:       "Change alias",
 			Description: "Change description",

pkg/apiserver/domain/service/rbac.go

@@ -51,7 +51,7 @@ var defaultProjectPermissionTemplate = []*model.PermissionTemplate{
 	{
 		Name:      "app-management",
 		Alias:     "App Management",
-		Resources: []string{"project:{projectName}/application:*/*", "definition:*"},
+		Resources: []string{"project:{projectName}/application:*/*", "definition:list", "definition:detail"},
 		Actions:   []string{"*"},
 		Effect:    "Allow",
 		Scope:     "project",

pkg/apiserver/domain/service/velaql.go

@@ -37,24 +37,14 @@ type VelaQLService interface {
 }
 
 type velaQLServiceImpl struct {
-	kubeClient client.Client
-	kubeConfig *rest.Config
+	KubeClient client.Client `inject:"kubeClient"`
+	KubeConfig *rest.Config  `inject:"kubeConfig"`
 	dm         discoverymapper.DiscoveryMapper
 	pd         *packages.PackageDiscover
 }
 
 // NewVelaQLService new velaQL service
 func NewVelaQLService() VelaQLService {
-	k8sClient, err := clients.GetKubeClient()
-	if err != nil {
-		log.Logger.Fatalf("get kubeclient failure %s", err.Error())
-	}
-
-	kubeConfig, err := clients.GetKubeConfig()
-	if err != nil {
-		log.Logger.Fatalf("get kubeconfig failure %s", err.Error())
-	}
-
 	dm, err := clients.GetDiscoverMapper()
 	if err != nil {
 		log.Logger.Fatalf("get discover mapper failure %s", err.Error())
@@ -65,10 +55,8 @@ func NewVelaQLService() VelaQLService {
 		log.Logger.Fatalf("get package discover failure %s", err.Error())
 	}
 	return &velaQLServiceImpl{
-		kubeClient: k8sClient,
-		kubeConfig: kubeConfig,
-		dm:         dm,
-		pd:         pd,
+		dm: dm,
+		pd: pd,
 	}
 }
 
@@ -79,7 +67,7 @@ func (v *velaQLServiceImpl) QueryView(ctx context.Context, velaQL string) (*apis
 		return nil, bcode.ErrParseVelaQL
 	}
 
-	queryValue, err := velaql.NewViewHandler(v.kubeClient, v.kubeConfig, v.dm, v.pd).QueryView(ctx, query)
+	queryValue, err := velaql.NewViewHandler(v.KubeClient, v.KubeConfig, v.dm, v.pd).QueryView(ctx, query)
 	if err != nil {
 		log.Logger.Errorf("fail to query the view %s", err.Error())
 		return nil, bcode.ErrViewQuery
@@ -88,6 +76,7 @@ func (v *velaQLServiceImpl) QueryView(ctx context.Context, velaQL string) (*apis
 	resp := apis.VelaQLViewResponse{}
 	err = queryValue.UnmarshalTo(&resp)
 	if err != nil {
+		log.Logger.Errorf("decode the velaQL response to json failure %s", err.Error())
 		return nil, bcode.ErrParseQuery2Json
 	}
 	return &resp, err

pkg/apiserver/infrastructure/clients/kubeclient.go

@@ -18,6 +18,7 @@ package clients
 
 import (
 	"errors"
+	"fmt"
 
 	"k8s.io/client-go/discovery"
 	"k8s.io/client-go/rest"
@@ -57,11 +58,7 @@ func GetKubeClient() (client.Client, error) {
 		return kubeClient, nil
 	}
 	if kubeConfig == nil {
-		conf, err := config.GetConfig()
-		if err != nil {
-			return nil, err
-		}
-		kubeConfig = conf
+		return nil, fmt.Errorf("please call SetKubeConfig first")
 	}
 	var err error
 	kubeClient, err = multicluster.Initialize(kubeConfig, false)
@@ -81,10 +78,8 @@ func GetKubeClient() (client.Client, error) {
 
 // GetKubeConfig create/get kube runtime config
 func GetKubeConfig() (*rest.Config, error) {
-	var err error
 	if kubeConfig == nil {
-		kubeConfig, err = config.GetConfig()
-		return kubeConfig, err
+		return nil, fmt.Errorf("please call SetKubeConfig first")
 	}
 	return kubeConfig, nil
 }

pkg/apiserver/server.go

@@ -61,37 +61,18 @@ type restServer struct {
 }
 
 // New create api server with config data
-func New(cfg config.Config) (a APIServer, err error) {
-	var ds datastore.DataStore
-	switch cfg.Datastore.Type {
-	case "mongodb":
-		ds, err = mongodb.New(context.Background(), cfg.Datastore)
-		if err != nil {
-			return nil, fmt.Errorf("create mongodb datastore instance failure %w", err)
-		}
-	case "kubeapi":
-		ds, err = kubeapi.New(context.Background(), cfg.Datastore)
-		if err != nil {
-			return nil, fmt.Errorf("create kubeapi datastore instance failure %w", err)
-		}
-	default:
-		return nil, fmt.Errorf("not support datastore type %s", cfg.Datastore.Type)
-	}
-
+func New(cfg config.Config) (a APIServer) {
 	s := &restServer{
 		webContainer:  restful.NewContainer(),
 		beanContainer: container.NewContainer(),
 		cfg:           cfg,
-		dataStore:     ds,
 	}
-	return s, nil
+	return s
 }
 
 func (s *restServer) buildIoCContainer() error {
 	// infrastructure
-	if err := s.beanContainer.ProvideWithName("datastore", s.dataStore); err != nil {
-		return fmt.Errorf("fail to provides the datastore bean to the container: %w", err)
-	}
+
 	err := clients.SetKubeConfig(s.cfg)
 	if err != nil {
 		return err
@@ -104,6 +85,26 @@ func (s *restServer) buildIoCContainer() error {
 	if err != nil {
 		return err
 	}
+	var ds datastore.DataStore
+	switch s.cfg.Datastore.Type {
+	case "mongodb":
+		ds, err = mongodb.New(context.Background(), s.cfg.Datastore)
+		if err != nil {
+			return fmt.Errorf("create mongodb datastore instance failure %w", err)
+		}
+	case "kubeapi":
+		ds, err = kubeapi.New(context.Background(), s.cfg.Datastore)
+		if err != nil {
+			return fmt.Errorf("create kubeapi datastore instance failure %w", err)
+		}
+	default:
+		return fmt.Errorf("not support datastore type %s", s.cfg.Datastore.Type)
+	}
+	s.dataStore = ds
+	if err := s.beanContainer.ProvideWithName("datastore", s.dataStore); err != nil {
+		return fmt.Errorf("fail to provides the datastore bean to the container: %w", err)
+	}
+
 	if err := s.beanContainer.ProvideWithName("kubeClient", kubeClient); err != nil {
 		return fmt.Errorf("fail to provides the kubeClient bean to the container: %w", err)
 	}

pkg/velaql/providers/query/types/health_status.go

@@ -21,13 +21,13 @@ type HealthStatusCode string
 
 const (
 	// HealthStatusHealthy  resource is healthy
-	HealthStatusHealthy HealthStatusCode = "HealthStatusHealthy"
+	HealthStatusHealthy HealthStatusCode = "Healthy"
 	// HealthStatusUnHealthy resource is unhealthy
-	HealthStatusUnHealthy HealthStatusCode = "HealthStatusUnHealthy"
+	HealthStatusUnHealthy HealthStatusCode = "UnHealthy"
 	// HealthStatusProgressing resource is still progressing
-	HealthStatusProgressing HealthStatusCode = "HealthStatusProgressing"
+	HealthStatusProgressing HealthStatusCode = "Progressing"
 	// HealthStatusUnKnown health status is unknown
-	HealthStatusUnKnown HealthStatusCode = "HealthStatusUnKnown"
+	HealthStatusUnKnown HealthStatusCode = "UnKnown"
 )
 
 // HealthStatus the resource health status

test/e2e-apiserver-test/suite_test.go

@@ -56,12 +56,6 @@ func TestE2eApiserverTest(t *testing.T) {
 
 // Suite test in e2e-apiserver-test relies on the pre-setup kubernetes environment
 var _ = BeforeSuite(func() {
-	By("new kube client")
-	var err error
-	k8sClient, err = clients.GetKubeClient()
-	Expect(err).Should(BeNil())
-	Expect(k8sClient).ToNot(BeNil())
-	By("new kube client success")
 
 	ctx := context.Background()
 
@@ -72,16 +66,17 @@ var _ = BeforeSuite(func() {
 			Database: "kubevela",
 		},
 		AddonCacheTime: 10 * time.Minute,
+		KubeQPS:        100,
+		KubeBurst:      300,
 	}
 	cfg.LeaderConfig.ID = uuid.New().String()
 	cfg.LeaderConfig.LockName = "apiserver-lock"
 	cfg.LeaderConfig.Duration = time.Second * 10
 
-	server, err := apiserver.New(cfg)
-	Expect(err).ShouldNot(HaveOccurred())
+	server := apiserver.New(cfg)
 	Expect(server).ShouldNot(BeNil())
 	go func() {
-		err = server.Run(ctx, make(chan error))
+		err := server.Run(ctx, make(chan error))
 		Expect(err).ShouldNot(HaveOccurred())
 	}()
 	By("wait for api server to start")
@@ -114,6 +109,9 @@ var _ = BeforeSuite(func() {
 			Expect(err).Should(BeNil())
 			return fmt.Errorf("rest service not ready code:%d message:%s", resp.StatusCode, code.Message)
 		}, time.Second*10, time.Millisecond*200).Should(BeNil())
+	var err error
+	k8sClient, err = clients.GetKubeClient()
+	Expect(err).ShouldNot(HaveOccurred())
 	By("api server started")
 })