[WIP] API refactor (#1737)

* refactor openpitrix API

Signed-off-by: hongming <talonwan@yunify.com>

* add openpitrix mock client

Signed-off-by: hongming <talonwan@yunify.com>

* refactor tenant API

Signed-off-by: hongming <talonwan@yunify.com>

* refactor IAM API

Signed-off-by: hongming <talonwan@yunify.com>

* refactor IAM API

Signed-off-by: hongming <talonwan@yunify.com>

pkg/apiserver/apiserver.go

@@ -32,7 +32,7 @@ type Dependencies struct {
 	// Injected Dependencies
 	KubeClient k8s.Client
 	S3         s3.Interface
-	OpenPitrix openpitrix.Interface
+	OpenPitrix openpitrix.Client
 	Monitoring monitoring.Interface
 	Logging    logging.Interface
 	Devops     devops.Interface

pkg/apiserver/iam/am.go

@@ -16,185 +16,3 @@
 
 */
 package iam
-
-import (
-	"github.com/emicklei/go-restful"
-	"k8s.io/api/rbac/v1"
-	k8serr "k8s.io/apimachinery/pkg/api/errors"
-	"kubesphere.io/kubesphere/pkg/server/params"
-	"net/http"
-	"sort"
-
-	"kubesphere.io/kubesphere/pkg/models/iam"
-	"kubesphere.io/kubesphere/pkg/models/iam/policy"
-	"kubesphere.io/kubesphere/pkg/server/errors"
-)
-
-type RoleList struct {
-	ClusterRoles []*v1.ClusterRole `json:"clusterRole" description:"cluster role list"`
-	Roles        []*v1.Role        `json:"roles" description:"role list"`
-}
-
-func ListRoleUsers(req *restful.Request, resp *restful.Response) {
-	roleName := req.PathParameter("role")
-	namespace := req.PathParameter("namespace")
-
-	users, err := iam.RoleUsers(namespace, roleName)
-
-	if err != nil {
-		resp.WriteHeaderAndEntity(http.StatusInternalServerError, errors.Wrap(err))
-		return
-	}
-
-	resp.WriteAsJson(users)
-}
-
-func ListClusterRoles(req *restful.Request, resp *restful.Response) {
-	conditions, err := params.ParseConditions(req.QueryParameter(params.ConditionsParam))
-	orderBy := req.QueryParameter(params.OrderByParam)
-	limit, offset := params.ParsePaging(req.QueryParameter(params.PagingParam))
-	reverse := params.ParseReverse(req)
-
-	if err != nil {
-		resp.WriteHeaderAndEntity(http.StatusBadRequest, errors.Wrap(err))
-		return
-	}
-
-	result, err := iam.ListClusterRoles(conditions, orderBy, reverse, limit, offset)
-
-	if err != nil {
-		resp.WriteHeaderAndEntity(http.StatusInternalServerError, errors.Wrap(err))
-		return
-	}
-
-	resp.WriteAsJson(result)
-
-}
-
-func ListRoles(req *restful.Request, resp *restful.Response) {
-	namespace := req.PathParameter("namespace")
-	conditions, err := params.ParseConditions(req.QueryParameter(params.ConditionsParam))
-	orderBy := req.QueryParameter(params.OrderByParam)
-	limit, offset := params.ParsePaging(req.QueryParameter(params.PagingParam))
-	reverse := params.ParseReverse(req)
-
-	if err != nil {
-		resp.WriteHeaderAndEntity(http.StatusBadRequest, errors.Wrap(err))
-		return
-	}
-
-	result, err := iam.ListRoles(namespace, conditions, orderBy, reverse, limit, offset)
-
-	if err != nil {
-		resp.WriteHeaderAndEntity(http.StatusInternalServerError, errors.Wrap(err))
-		return
-	}
-
-	resp.WriteAsJson(result)
-
-}
-
-// List users by namespace
-func ListNamespaceUsers(req *restful.Request, resp *restful.Response) {
-
-	namespace := req.PathParameter("namespace")
-
-	users, err := iam.NamespaceUsers(namespace)
-
-	if err != nil {
-		resp.WriteHeaderAndEntity(http.StatusInternalServerError, errors.Wrap(err))
-		return
-	}
-
-	// sort by time by default
-	sort.Slice(users, func(i, j int) bool {
-		return users[i].RoleBindTime.After(*users[j].RoleBindTime)
-	})
-
-	resp.WriteAsJson(users)
-}
-
-func ListUserRoles(req *restful.Request, resp *restful.Response) {
-
-	username := req.PathParameter("user")
-
-	roles, err := iam.GetUserRoles("", username)
-
-	if err != nil {
-		resp.WriteHeaderAndEntity(http.StatusInternalServerError, errors.Wrap(err))
-		return
-	}
-
-	_, clusterRoles, err := iam.GetUserClusterRoles(username)
-
-	if err != nil {
-		resp.WriteHeaderAndEntity(http.StatusInternalServerError, errors.Wrap(err))
-		return
-	}
-
-	roleList := RoleList{}
-	roleList.Roles = roles
-	roleList.ClusterRoles = clusterRoles
-
-	resp.WriteAsJson(roleList)
-}
-
-func RulesMapping(req *restful.Request, resp *restful.Response) {
-	rules := policy.RoleRuleMapping
-	resp.WriteAsJson(rules)
-}
-
-func ClusterRulesMapping(req *restful.Request, resp *restful.Response) {
-	rules := policy.ClusterRoleRuleMapping
-	resp.WriteAsJson(rules)
-}
-
-func ListClusterRoleRules(req *restful.Request, resp *restful.Response) {
-	clusterRoleName := req.PathParameter("clusterrole")
-	rules, err := iam.GetClusterRoleSimpleRules(clusterRoleName)
-	if err != nil {
-		resp.WriteError(http.StatusInternalServerError, err)
-		return
-	}
-	resp.WriteAsJson(rules)
-}
-
-func ListClusterRoleUsers(req *restful.Request, resp *restful.Response) {
-	clusterRoleName := req.PathParameter("clusterrole")
-	conditions, err := params.ParseConditions(req.QueryParameter(params.ConditionsParam))
-	orderBy := req.QueryParameter(params.OrderByParam)
-	limit, offset := params.ParsePaging(req.QueryParameter(params.PagingParam))
-	reverse := params.ParseReverse(req)
-
-	if err != nil {
-		resp.WriteHeaderAndEntity(http.StatusBadRequest, errors.Wrap(err))
-		return
-	}
-
-	result, err := iam.ListClusterRoleUsers(clusterRoleName, conditions, orderBy, reverse, limit, offset)
-
-	if err != nil {
-		if k8serr.IsNotFound(err) {
-			resp.WriteError(http.StatusNotFound, err)
-		} else {
-			resp.WriteError(http.StatusInternalServerError, err)
-		}
-		return
-	}
-
-	resp.WriteAsJson(result)
-}
-
-func ListRoleRules(req *restful.Request, resp *restful.Response) {
-	namespaceName := req.PathParameter("namespace")
-	roleName := req.PathParameter("role")
-
-	rules, err := iam.GetRoleSimpleRules(namespaceName, roleName)
-
-	if err != nil {
-		resp.WriteHeaderAndEntity(http.StatusInternalServerError, errors.Wrap(err))
-		return
-	}
-
-	resp.WriteAsJson(rules)
-}

pkg/apiserver/iam/auth.go

@@ -19,38 +19,15 @@ package iam
 
 import (
 	"fmt"
-	"github.com/dgrijalva/jwt-go"
 	"github.com/emicklei/go-restful"
-	"k8s.io/klog"
+	iamv1alpha2 "kubesphere.io/kubesphere/pkg/api/iam/v1alpha2"
 	"kubesphere.io/kubesphere/pkg/models"
 	"kubesphere.io/kubesphere/pkg/models/iam"
 	"kubesphere.io/kubesphere/pkg/server/errors"
 	"kubesphere.io/kubesphere/pkg/utils/iputil"
-	"kubesphere.io/kubesphere/pkg/utils/jwtutil"
 	"net/http"
 )
 
-type Spec struct {
-	Token string `json:"token" description:"access token"`
-}
-
-type Status struct {
-	Authenticated bool                   `json:"authenticated" description:"is authenticated"`
-	User          map[string]interface{} `json:"user,omitempty" description:"user info"`
-}
-
-type TokenReview struct {
-	APIVersion string  `json:"apiVersion" description:"Kubernetes API version"`
-	Kind       string  `json:"kind" description:"kind of the API object"`
-	Spec       *Spec   `json:"spec,omitempty"`
-	Status     *Status `json:"status,omitempty" description:"token review status"`
-}
-
-type LoginRequest struct {
-	Username string `json:"username" description:"username"`
-	Password string `json:"password" description:"password"`
-}
-
 type OAuthRequest struct {
 	GrantType    string `json:"grant_type"`
 	Username     string `json:"username,omitempty" description:"username"`
@@ -58,36 +35,6 @@ type OAuthRequest struct {
 	RefreshToken string `json:"refresh_token,omitempty"`
 }
 
-const (
-	KindTokenReview = "TokenReview"
-)
-
-func Login(req *restful.Request, resp *restful.Response) {
-	var loginRequest LoginRequest
-
-	err := req.ReadEntity(&loginRequest)
-
-	if err != nil || loginRequest.Username == "" || loginRequest.Password == "" {
-		resp.WriteHeaderAndEntity(http.StatusUnauthorized, errors.New("incorrect username or password"))
-		return
-	}
-
-	ip := iputil.RemoteIp(req.Request)
-
-	token, err := iam.Login(loginRequest.Username, loginRequest.Password, ip)
-
-	if err != nil {
-		if serviceError, ok := err.(restful.ServiceError); ok {
-			resp.WriteHeaderAndEntity(serviceError.Code, errors.New(serviceError.Message))
-			return
-		}
-		resp.WriteHeaderAndEntity(http.StatusUnauthorized, errors.Wrap(err))
-		return
-	}
-
-	resp.WriteAsJson(token)
-}
-
 func OAuth(req *restful.Request, resp *restful.Response) {
 
 	authRequest := &OAuthRequest{}
@@ -120,72 +67,3 @@ func OAuth(req *restful.Request, resp *restful.Response) {
 	resp.WriteEntity(result)
 
 }
-
-// k8s token review
-func TokenReviewHandler(req *restful.Request, resp *restful.Response) {
-	var tokenReview TokenReview
-
-	err := req.ReadEntity(&tokenReview)
-
-	if err != nil {
-		resp.WriteHeaderAndEntity(http.StatusBadRequest, errors.Wrap(err))
-		return
-	}
-
-	if tokenReview.Spec == nil {
-		resp.WriteHeaderAndEntity(http.StatusBadRequest, errors.New("token must not be null"))
-		return
-	}
-
-	uToken := tokenReview.Spec.Token
-
-	token, err := jwtutil.ValidateToken(uToken)
-
-	if err != nil {
-		klog.Errorln("token review failed", uToken, err)
-		failed := TokenReview{APIVersion: tokenReview.APIVersion,
-			Kind: KindTokenReview,
-			Status: &Status{
-				Authenticated: false,
-			},
-		}
-		resp.WriteAsJson(failed)
-		return
-	}
-
-	claims := token.Claims.(jwt.MapClaims)
-
-	username, ok := claims["username"].(string)
-
-	if !ok {
-		resp.WriteHeaderAndEntity(http.StatusBadRequest, errors.New("username not found"))
-		return
-	}
-
-	user, err := iam.GetUserInfo(username)
-
-	if err != nil {
-		resp.WriteHeaderAndEntity(http.StatusInternalServerError, errors.Wrap(err))
-		return
-	}
-
-	groups, err := iam.GetUserGroups(username)
-
-	if err != nil {
-		resp.WriteHeaderAndEntity(http.StatusInternalServerError, errors.Wrap(err))
-		return
-	}
-
-	user.Groups = groups
-
-	success := TokenReview{APIVersion: tokenReview.APIVersion,
-		Kind: KindTokenReview,
-		Status: &Status{
-			Authenticated: true,
-			User:          map[string]interface{}{"username": user.Username, "uid": user.Username, "groups": user.Groups},
-		},
-	}
-
-	resp.WriteAsJson(success)
-	return
-}

pkg/apiserver/iam/groups.go

@@ -136,7 +136,7 @@ func ListGroupUsers(req *restful.Request, resp *restful.Response) {
 		return
 	}
 
-	users := make([]*models.User, 0)
+	users := make([]*iam.User, 0)
 
 	modify := false
 

pkg/apiserver/iam/im.go

@@ -29,60 +29,10 @@ import (
 	"github.com/go-ldap/ldap"
 	rbacv1 "k8s.io/api/rbac/v1"
 	"kubesphere.io/kubesphere/pkg/constants"
-	"kubesphere.io/kubesphere/pkg/models"
 	"kubesphere.io/kubesphere/pkg/models/iam"
 	"kubesphere.io/kubesphere/pkg/server/errors"
 )
 
-func CreateUser(req *restful.Request, resp *restful.Response) {
-	var user models.User
-
-	err := req.ReadEntity(&user)
-
-	if err != nil {
-		klog.Info(err)
-		resp.WriteHeaderAndEntity(http.StatusBadRequest, errors.Wrap(err))
-		return
-	}
-
-	if user.Username == "" {
-		err = fmt.Errorf("invalid username: %s", user.Username)
-		klog.Info(err, user.Username)
-		resp.WriteHeaderAndEntity(http.StatusBadRequest, errors.Wrap(err))
-		return
-	}
-
-	// Parses a single RFC 5322 address, e.g. "Barry Gibbs <bg@example.com>"
-	if _, err = mail.ParseAddress(user.Email); err != nil {
-		err = fmt.Errorf("invalid email: %s", user.Email)
-		klog.Info(err, user.Email)
-		resp.WriteHeaderAndEntity(http.StatusBadRequest, errors.Wrap(err))
-		return
-	}
-
-	if len(user.Password) < 6 {
-		err = fmt.Errorf("invalid password")
-		klog.Info(err)
-		resp.WriteHeaderAndEntity(http.StatusBadRequest, errors.Wrap(err))
-		return
-	}
-
-	created, err := iam.CreateUser(&user)
-
-	if err != nil {
-		if ldap.IsErrorWithCode(err, ldap.LDAPResultEntryAlreadyExists) {
-			klog.Info(err)
-			resp.WriteHeaderAndEntity(http.StatusConflict, errors.Wrap(err))
-			return
-		}
-		klog.Info(err)
-		resp.WriteHeaderAndEntity(http.StatusInternalServerError, errors.Wrap(err))
-		return
-	}
-
-	resp.WriteAsJson(created)
-}
-
 func DeleteUser(req *restful.Request, resp *restful.Response) {
 	username := req.PathParameter("user")
 
@@ -110,7 +60,7 @@ func UpdateUser(req *restful.Request, resp *restful.Response) {
 
 	usernameInPath := req.PathParameter("user")
 	usernameInHeader := req.HeaderParameter(constants.UserNameHeader)
-	var user models.User
+	var user iam.User
 
 	err := req.ReadEntity(&user)
 
@@ -254,8 +204,8 @@ func DescribeUser(req *restful.Request, resp *restful.Response) {
 	}
 
 	result := struct {
-		*models.User
-		ClusterRules []models.SimpleRule `json:"cluster_rules"`
+		*iam.User
+		ClusterRules []iam.SimpleRule `json:"cluster_rules"`
 	}{
 		User:         user,
 		ClusterRules: clusterRules,

pkg/apiserver/iam/workspaces.go

@@ -21,7 +21,6 @@ import (
 	"github.com/emicklei/go-restful"
 	k8serr "k8s.io/apimachinery/pkg/api/errors"
 	"kubesphere.io/kubesphere/pkg/constants"
-	"kubesphere.io/kubesphere/pkg/models"
 	"kubesphere.io/kubesphere/pkg/models/iam"
 	"kubesphere.io/kubesphere/pkg/models/workspaces"
 	"kubesphere.io/kubesphere/pkg/server/errors"
@@ -113,7 +112,7 @@ func ListDevopsRoleRules(req *restful.Request, resp *restful.Response) {
 
 func InviteUser(req *restful.Request, resp *restful.Response) {
 	workspace := req.PathParameter("workspace")
-	var user models.User
+	var user iam.User
 	err := req.ReadEntity(&user)
 	if err != nil {
 		resp.WriteHeaderAndEntity(http.StatusBadRequest, errors.Wrap(err))

pkg/apiserver/openpitrix/applications.go

@@ -1,280 +0,0 @@
-/*
- *
- * Copyright 2019 The KubeSphere Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- * /
- */
-
-package openpitrix
-
-import (
-	"fmt"
-	"github.com/emicklei/go-restful"
-	"google.golang.org/grpc/codes"
-	"google.golang.org/grpc/status"
-	"k8s.io/api/core/v1"
-	"k8s.io/klog"
-	"kubesphere.io/kubesphere/pkg/constants"
-	"kubesphere.io/kubesphere/pkg/models"
-	"kubesphere.io/kubesphere/pkg/models/openpitrix/type"
-	"kubesphere.io/kubesphere/pkg/models/resources/v1alpha2"
-	"kubesphere.io/kubesphere/pkg/server/errors"
-	"kubesphere.io/kubesphere/pkg/server/params"
-	"kubesphere.io/kubesphere/pkg/simple/client"
-	"net/http"
-)
-
-func ListApplications(req *restful.Request, resp *restful.Response) {
-	limit, offset := params.ParsePaging(req.QueryParameter(params.PagingParam))
-	namespaceName := req.PathParameter("namespace")
-	conditions, err := params.ParseConditions(req.QueryParameter(params.ConditionsParam))
-	orderBy := req.QueryParameter(params.OrderByParam)
-	reverse := params.ParseReverse(req)
-
-	if orderBy == "" {
-		orderBy = "create_time"
-		reverse = true
-	}
-
-	if err != nil {
-		resp.WriteHeaderAndEntity(http.StatusBadRequest, errors.Wrap(err))
-		return
-	}
-
-	if namespaceName != "" {
-		namespace, err := v1alpha2.GetResource("", v1alpha2.Namespaces, namespaceName)
-
-		if err != nil {
-			klog.Errorln(err)
-			resp.WriteHeaderAndEntity(http.StatusInternalServerError, errors.Wrap(err))
-			return
-		}
-		var runtimeId string
-
-		if ns, ok := namespace.(*v1.Namespace); ok {
-			runtimeId = ns.Annotations[constants.OpenPitrixRuntimeAnnotationKey]
-		}
-
-		if runtimeId == "" {
-			resp.WriteAsJson(models.PageableResponse{Items: []interface{}{}, TotalCount: 0})
-			return
-		} else {
-			conditions.Match["runtime_id"] = runtimeId
-		}
-	}
-
-	result, err := openpitrix.ListApplications(conditions, limit, offset, orderBy, reverse)
-
-	if _, notEnabled := err.(client.ClientSetNotEnabledError); notEnabled {
-		resp.WriteHeaderAndEntity(http.StatusNotImplemented, errors.Wrap(err))
-		return
-	}
-
-	if err != nil {
-		klog.Errorln(err)
-		resp.WriteHeaderAndEntity(http.StatusInternalServerError, errors.Wrap(err))
-		return
-	}
-
-	resp.WriteAsJson(result)
-}
-
-func DescribeApplication(req *restful.Request, resp *restful.Response) {
-	clusterId := req.PathParameter("application")
-	namespaceName := req.PathParameter("namespace")
-	app, err := openpitrix.DescribeApplication(namespaceName, clusterId)
-
-	if _, notEnabled := err.(client.ClientSetNotEnabledError); notEnabled {
-		resp.WriteHeaderAndEntity(http.StatusNotImplemented, errors.Wrap(err))
-		return
-	}
-	if status.Code(err) == codes.NotFound {
-		resp.WriteHeaderAndEntity(http.StatusNotFound, errors.Wrap(err))
-		return
-	}
-	if err != nil {
-		klog.Errorln(err)
-		resp.WriteHeaderAndEntity(http.StatusInternalServerError, errors.Wrap(err))
-		return
-	}
-
-	namespace, err := resources.GetResource("", v1alpha2.Namespaces, namespaceName)
-
-	if err != nil {
-		klog.Errorln(err)
-		resp.WriteHeaderAndEntity(http.StatusInternalServerError, errors.Wrap(err))
-		return
-	}
-
-	var runtimeId string
-
-	if ns, ok := namespace.(*v1.Namespace); ok {
-		runtimeId = ns.Annotations[constants.OpenPitrixRuntimeAnnotationKey]
-	}
-
-	if runtimeId != app.Cluster.RuntimeId {
-		err = fmt.Errorf("rumtime not match %s,%s", app.Cluster.RuntimeId, runtimeId)
-		klog.V(4).Info(err)
-		resp.WriteHeaderAndEntity(http.StatusForbidden, errors.Wrap(err))
-		return
-	}
-
-	resp.WriteEntity(app)
-	return
-}
-
-func CreateApplication(req *restful.Request, resp *restful.Response) {
-	namespace := req.PathParameter("namespace")
-	var createClusterRequest types.CreateClusterRequest
-	err := req.ReadEntity(&createClusterRequest)
-	if err != nil {
-		resp.WriteHeaderAndEntity(http.StatusBadRequest, errors.Wrap(err))
-		return
-	}
-	createClusterRequest.Username = req.HeaderParameter(constants.UserNameHeader)
-
-	err = openpitrix.CreateApplication(namespace, createClusterRequest)
-
-	if _, notEnabled := err.(client.ClientSetNotEnabledError); notEnabled {
-		resp.WriteHeaderAndEntity(http.StatusNotImplemented, errors.Wrap(err))
-		return
-	}
-
-	if err != nil {
-		resp.WriteHeaderAndEntity(http.StatusInternalServerError, errors.Wrap(err))
-		return
-	}
-	resp.WriteEntity(errors.None)
-}
-
-func ModifyApplication(req *restful.Request, resp *restful.Response) {
-	var modifyClusterAttributesRequest types.ModifyClusterAttributesRequest
-	clusterId := req.PathParameter("application")
-	namespaceName := req.PathParameter("namespace")
-	err := req.ReadEntity(&modifyClusterAttributesRequest)
-	if err != nil {
-		resp.WriteHeaderAndEntity(http.StatusBadRequest, errors.Wrap(err))
-		return
-	}
-
-	app, err := openpitrix.DescribeApplication(namespaceName, clusterId)
-
-	if _, notEnabled := err.(client.ClientSetNotEnabledError); notEnabled {
-		resp.WriteHeaderAndEntity(http.StatusNotImplemented, errors.Wrap(err))
-		return
-	}
-
-	if status.Code(err) == codes.NotFound {
-		resp.WriteHeaderAndEntity(http.StatusNotFound, errors.Wrap(err))
-		return
-	}
-
-	if err != nil {
-		klog.Errorln(err)
-		resp.WriteHeaderAndEntity(http.StatusInternalServerError, errors.Wrap(err))
-		return
-	}
-
-	namespace, err := resources.GetResource("", v1alpha2.Namespaces, namespaceName)
-
-	if err != nil {
-		klog.Errorln(err)
-		resp.WriteHeaderAndEntity(http.StatusInternalServerError, errors.Wrap(err))
-		return
-	}
-	var runtimeId string
-
-	if ns, ok := namespace.(*v1.Namespace); ok {
-		runtimeId = ns.Annotations[constants.OpenPitrixRuntimeAnnotationKey]
-	}
-
-	if runtimeId != app.Cluster.RuntimeId {
-		err = fmt.Errorf("rumtime not match %s,%s", app.Cluster.RuntimeId, runtimeId)
-		klog.V(4).Info(err)
-		resp.WriteHeaderAndEntity(http.StatusForbidden, errors.Wrap(err))
-		return
-	}
-
-	err = openpitrix.PatchApplication(&modifyClusterAttributesRequest)
-
-	if status.Code(err) == codes.NotFound {
-		resp.WriteHeaderAndEntity(http.StatusNotFound, errors.Wrap(err))
-		return
-	}
-
-	if err != nil {
-		klog.Errorln(err)
-		resp.WriteHeaderAndEntity(http.StatusInternalServerError, errors.Wrap(err))
-		return
-	}
-
-	resp.WriteEntity(errors.None)
-}
-
-func DeleteApplication(req *restful.Request, resp *restful.Response) {
-	clusterId := req.PathParameter("application")
-	namespaceName := req.PathParameter("namespace")
-	app, err := openpitrix.DescribeApplication(namespaceName, clusterId)
-
-	if _, notEnabled := err.(client.ClientSetNotEnabledError); notEnabled {
-		resp.WriteHeaderAndEntity(http.StatusNotImplemented, errors.Wrap(err))
-		return
-	}
-
-	if status.Code(err) == codes.NotFound {
-		resp.WriteHeaderAndEntity(http.StatusNotFound, errors.Wrap(err))
-		return
-	}
-
-	if err != nil {
-		klog.Errorln(err)
-		resp.WriteHeaderAndEntity(http.StatusInternalServerError, errors.Wrap(err))
-		return
-	}
-
-	namespace, err := resources.GetResource("", v1alpha2.Namespaces, namespaceName)
-
-	if err != nil {
-		klog.Errorln(err)
-		resp.WriteHeaderAndEntity(http.StatusInternalServerError, errors.Wrap(err))
-		return
-	}
-	var runtimeId string
-
-	if ns, ok := namespace.(*v1.Namespace); ok {
-		runtimeId = ns.Annotations[constants.OpenPitrixRuntimeAnnotationKey]
-	}
-
-	if runtimeId != app.Cluster.RuntimeId {
-		err = fmt.Errorf("rumtime not match %s,%s", app.Cluster.RuntimeId, runtimeId)
-		klog.V(4).Info(err)
-		resp.WriteHeaderAndEntity(http.StatusForbidden, errors.Wrap(err))
-		return
-	}
-
-	err = openpitrix.DeleteApplication(clusterId)
-
-	if status.Code(err) == codes.NotFound {
-		resp.WriteHeaderAndEntity(http.StatusNotFound, errors.Wrap(err))
-		return
-	}
-
-	if err != nil {
-		klog.Errorln(err)
-		resp.WriteHeaderAndEntity(http.StatusInternalServerError, errors.Wrap(err))
-		return
-	}
-
-	resp.WriteEntity(errors.None)
-}

pkg/apiserver/openpitrix/apps.go

@@ -1,548 +0,0 @@
-/*
- *
- * Copyright 2019 The KubeSphere Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- * /
- */
-
-package openpitrix
-
-import (
-	"github.com/emicklei/go-restful"
-	"google.golang.org/grpc/codes"
-	"google.golang.org/grpc/status"
-	"k8s.io/klog"
-	"kubesphere.io/kubesphere/pkg/constants"
-	"kubesphere.io/kubesphere/pkg/models/openpitrix/app"
-	"kubesphere.io/kubesphere/pkg/models/openpitrix/type"
-	"kubesphere.io/kubesphere/pkg/server/errors"
-	"kubesphere.io/kubesphere/pkg/server/params"
-	"kubesphere.io/kubesphere/pkg/simple/client"
-	"net/http"
-	"strconv"
-	"strings"
-)
-
-func GetAppVersionPackage(req *restful.Request, resp *restful.Response) {
-	appId := req.PathParameter("app")
-	versionId := req.PathParameter("version")
-
-	result, err := app.GetAppVersionPackage(appId, versionId)
-
-	if _, notEnabled := err.(client.ClientSetNotEnabledError); notEnabled {
-		resp.WriteHeaderAndEntity(http.StatusNotImplemented, errors.Wrap(err))
-		return
-	}
-
-	if err != nil {
-		klog.Errorln(err)
-		resp.WriteHeaderAndEntity(http.StatusInternalServerError, errors.Wrap(err))
-		return
-	}
-
-	resp.WriteEntity(result)
-}
-
-func DoAppAction(req *restful.Request, resp *restful.Response) {
-	var doActionRequest types.ActionRequest
-	err := req.ReadEntity(&doActionRequest)
-	if err != nil {
-		resp.WriteHeaderAndEntity(http.StatusBadRequest, errors.Wrap(err))
-		return
-	}
-
-	appId := req.PathParameter("app")
-
-	err = app.DoAppAction(appId, &doActionRequest)
-	if status.Code(err) == codes.NotFound {
-		resp.WriteHeaderAndEntity(http.StatusNotFound, errors.Wrap(err))
-		return
-	}
-
-	if status.Code(err) == codes.InvalidArgument {
-		resp.WriteHeaderAndEntity(http.StatusBadRequest, errors.Wrap(err))
-		return
-	}
-
-	if err != nil {
-		klog.Errorln(err)
-		resp.WriteHeaderAndEntity(http.StatusInternalServerError, errors.Wrap(err))
-		return
-	}
-
-	resp.WriteEntity(errors.None)
-}
-
-func DoAppVersionAction(req *restful.Request, resp *restful.Response) {
-	var doActionRequest types.ActionRequest
-	err := req.ReadEntity(&doActionRequest)
-	if err != nil {
-		resp.WriteHeaderAndEntity(http.StatusBadRequest, errors.Wrap(err))
-		return
-	}
-	doActionRequest.Username = req.HeaderParameter(constants.UserNameHeader)
-
-	versionId := req.PathParameter("version")
-
-	err = app.DoAppVersionAction(versionId, &doActionRequest)
-	if status.Code(err) == codes.NotFound {
-		resp.WriteHeaderAndEntity(http.StatusNotFound, errors.Wrap(err))
-		return
-	}
-
-	if status.Code(err) == codes.InvalidArgument {
-		resp.WriteHeaderAndEntity(http.StatusBadRequest, errors.Wrap(err))
-		return
-	}
-
-	if err != nil {
-		klog.Errorln(err)
-		resp.WriteHeaderAndEntity(http.StatusInternalServerError, errors.Wrap(err))
-		return
-	}
-
-	resp.WriteEntity(errors.None)
-}
-
-func GetAppVersionFiles(req *restful.Request, resp *restful.Response) {
-	versionId := req.PathParameter("version")
-	getAppVersionFilesRequest := &types.GetAppVersionFilesRequest{}
-	if f := req.QueryParameter("files"); f != "" {
-		getAppVersionFilesRequest.Files = strings.Split(f, ",")
-	}
-
-	result, err := app.GetAppVersionFiles(versionId, getAppVersionFilesRequest)
-
-	if _, notEnabled := err.(client.ClientSetNotEnabledError); notEnabled {
-		resp.WriteHeaderAndEntity(http.StatusNotImplemented, errors.Wrap(err))
-		return
-	}
-
-	if status.Code(err) == codes.NotFound {
-		resp.WriteHeaderAndEntity(http.StatusNotFound, errors.Wrap(err))
-		return
-	}
-
-	if err != nil {
-		klog.Errorln(err)
-		resp.WriteHeaderAndEntity(http.StatusInternalServerError, errors.Wrap(err))
-		return
-	}
-
-	resp.WriteEntity(result)
-}
-
-func ListAppVersionAudits(req *restful.Request, resp *restful.Response) {
-	conditions, err := params.ParseConditions(req.QueryParameter(params.ConditionsParam))
-	orderBy := req.QueryParameter(params.OrderByParam)
-	limit, offset := params.ParsePaging(req.QueryParameter(params.PagingParam))
-	reverse := params.ParseReverse(req)
-	appId := req.PathParameter("app")
-	versionId := req.PathParameter("version")
-	if orderBy == "" {
-		orderBy = "status_time"
-		reverse = true
-	}
-	if err != nil {
-		resp.WriteHeaderAndEntity(http.StatusBadRequest, errors.Wrap(err))
-		return
-	}
-	conditions.Match["app"] = appId
-	if versionId != "" {
-		conditions.Match["version"] = versionId
-	}
-
-	result, err := app.ListAppVersionAudits(conditions, orderBy, reverse, limit, offset)
-
-	if _, notEnabled := err.(client.ClientSetNotEnabledError); notEnabled {
-		resp.WriteHeaderAndEntity(http.StatusNotImplemented, errors.Wrap(err))
-		return
-	}
-
-	if err != nil {
-		klog.Errorln(err)
-		resp.WriteHeaderAndEntity(http.StatusInternalServerError, errors.Wrap(err))
-		return
-	}
-
-	resp.WriteEntity(result)
-}
-
-func ListReviews(req *restful.Request, resp *restful.Response) {
-	conditions, err := params.ParseConditions(req.QueryParameter(params.ConditionsParam))
-	orderBy := req.QueryParameter(params.OrderByParam)
-	limit, offset := params.ParsePaging(req.QueryParameter(params.PagingParam))
-	reverse := params.ParseReverse(req)
-	if orderBy == "" {
-		orderBy = "status_time"
-		reverse = true
-	}
-	if err != nil {
-		resp.WriteHeaderAndEntity(http.StatusBadRequest, errors.Wrap(err))
-		return
-	}
-
-	result, err := app.ListAppVersionReviews(conditions, orderBy, reverse, limit, offset)
-
-	if _, notEnabled := err.(client.ClientSetNotEnabledError); notEnabled {
-		resp.WriteHeaderAndEntity(http.StatusNotImplemented, errors.Wrap(err))
-		return
-	}
-
-	if err != nil {
-		klog.Errorln(err)
-		resp.WriteHeaderAndEntity(http.StatusInternalServerError, errors.Wrap(err))
-		return
-	}
-
-	resp.WriteEntity(result)
-}
-
-func ListAppVersions(req *restful.Request, resp *restful.Response) {
-	conditions, err := params.ParseConditions(req.QueryParameter(params.ConditionsParam))
-	orderBy := req.QueryParameter(params.OrderByParam)
-	limit, offset := params.ParsePaging(req.QueryParameter(params.PagingParam))
-	reverse := params.ParseReverse(req)
-	appId := req.PathParameter("app")
-	statistics, _ := strconv.ParseBool(req.QueryParameter("statistics"))
-	if orderBy == "" {
-		orderBy = "create_time"
-		reverse = true
-	}
-	if err != nil {
-		resp.WriteHeaderAndEntity(http.StatusBadRequest, errors.Wrap(err))
-		return
-	}
-	conditions.Match["app"] = appId
-
-	result, err := app.ListAppVersions(conditions, orderBy, reverse, limit, offset)
-
-	if _, notEnabled := err.(client.ClientSetNotEnabledError); notEnabled {
-		resp.WriteHeaderAndEntity(http.StatusNotImplemented, errors.Wrap(err))
-		return
-	}
-
-	if err != nil {
-		klog.Errorln(err)
-		resp.WriteHeaderAndEntity(http.StatusInternalServerError, errors.Wrap(err))
-		return
-	}
-
-	if statistics {
-		for _, item := range result.Items {
-			if version, ok := item.(*types.AppVersion); ok {
-				statisticsResult, err := openpitrix.ListApplications(&params.Conditions{Match: map[string]string{"app_id": version.AppId, "version_id": version.VersionId}}, 0, 0, "", false)
-				if err != nil {
-					klog.Errorln(err)
-					resp.WriteHeaderAndEntity(http.StatusInternalServerError, errors.Wrap(err))
-					return
-				}
-				version.ClusterTotal = &statisticsResult.TotalCount
-			}
-		}
-	}
-
-	resp.WriteEntity(result)
-}
-
-func ListApps(req *restful.Request, resp *restful.Response) {
-	conditions, err := params.ParseConditions(req.QueryParameter(params.ConditionsParam))
-	orderBy := req.QueryParameter(params.OrderByParam)
-	limit, offset := params.ParsePaging(req.QueryParameter(params.PagingParam))
-	reverse := params.ParseReverse(req)
-	statistics, _ := strconv.ParseBool(req.QueryParameter("statistics"))
-	if orderBy == "" {
-		orderBy = "create_time"
-		reverse = true
-	}
-
-	if err != nil {
-		resp.WriteHeaderAndEntity(http.StatusBadRequest, errors.Wrap(err))
-		return
-	}
-
-	result, err := app.ListApps(conditions, orderBy, reverse, limit, offset)
-
-	if _, notEnabled := err.(client.ClientSetNotEnabledError); notEnabled {
-		resp.WriteHeaderAndEntity(http.StatusNotImplemented, errors.Wrap(err))
-		return
-	}
-
-	if err != nil {
-		klog.Errorln(err)
-		resp.WriteHeaderAndEntity(http.StatusInternalServerError, errors.Wrap(err))
-		return
-	}
-
-	if statistics {
-		for _, item := range result.Items {
-			if app, ok := item.(*types.App); ok {
-				status := "active|used|enabled|stopped|pending|creating|upgrading|updating|rollbacking|stopping|starting|recovering|resizing|scaling|deleting"
-				statisticsResult, err := openpitrix.ListApplications(&params.Conditions{Match: map[string]string{"app_id": app.AppId, "status": status}}, 0, 0, "", false)
-				if err != nil {
-					klog.Errorln(err)
-					resp.WriteHeaderAndEntity(http.StatusInternalServerError, errors.Wrap(err))
-					return
-				}
-				app.ClusterTotal = &statisticsResult.TotalCount
-			}
-		}
-	}
-
-	resp.WriteEntity(result)
-}
-
-func ModifyApp(req *restful.Request, resp *restful.Response) {
-
-	var patchAppRequest types.ModifyAppRequest
-	err := req.ReadEntity(&patchAppRequest)
-	appId := req.PathParameter("app")
-
-	if err != nil {
-		resp.WriteHeaderAndEntity(http.StatusBadRequest, errors.Wrap(err))
-		return
-	}
-
-	err = app.PatchApp(appId, &patchAppRequest)
-
-	if _, notEnabled := err.(client.ClientSetNotEnabledError); notEnabled {
-		resp.WriteHeaderAndEntity(http.StatusNotImplemented, errors.Wrap(err))
-		return
-	}
-
-	if status.Code(err) == codes.NotFound {
-		resp.WriteHeaderAndEntity(http.StatusNotFound, errors.Wrap(err))
-		return
-	}
-
-	if status.Code(err) == codes.InvalidArgument {
-		resp.WriteHeaderAndEntity(http.StatusBadRequest, errors.Wrap(err))
-		return
-	}
-
-	if err != nil {
-		resp.WriteHeaderAndEntity(http.StatusInternalServerError, errors.Wrap(err))
-		return
-	}
-
-	resp.WriteEntity(errors.None)
-}
-
-func DescribeApp(req *restful.Request, resp *restful.Response) {
-	appId := req.PathParameter("app")
-
-	result, err := app.DescribeApp(appId)
-
-	if _, notEnabled := err.(client.ClientSetNotEnabledError); notEnabled {
-		resp.WriteHeaderAndEntity(http.StatusNotImplemented, errors.Wrap(err))
-		return
-	}
-
-	if status.Code(err) == codes.NotFound {
-		resp.WriteHeaderAndEntity(http.StatusNotFound, errors.Wrap(err))
-		return
-	}
-
-	if err != nil {
-		resp.WriteHeaderAndEntity(http.StatusInternalServerError, errors.Wrap(err))
-		return
-	}
-
-	resp.WriteEntity(result)
-}
-
-func DeleteApp(req *restful.Request, resp *restful.Response) {
-	appId := req.PathParameter("app")
-
-	err := app.DeleteApp(appId)
-
-	if _, notEnabled := err.(client.ClientSetNotEnabledError); notEnabled {
-		resp.WriteHeaderAndEntity(http.StatusNotImplemented, errors.Wrap(err))
-		return
-	}
-
-	if status.Code(err) == codes.NotFound {
-		resp.WriteHeaderAndEntity(http.StatusNotFound, errors.Wrap(err))
-		return
-	}
-
-	if err != nil {
-		resp.WriteHeaderAndEntity(http.StatusInternalServerError, errors.Wrap(err))
-		return
-	}
-
-	resp.WriteEntity(errors.None)
-}
-
-func CreateApp(req *restful.Request, resp *restful.Response) {
-	createAppRequest := &types.CreateAppRequest{}
-	err := req.ReadEntity(createAppRequest)
-	if err != nil {
-		resp.WriteHeaderAndEntity(http.StatusBadRequest, errors.Wrap(err))
-		return
-	}
-
-	createAppRequest.Username = req.HeaderParameter(constants.UserNameHeader)
-
-	validate, _ := strconv.ParseBool(req.QueryParameter("validate"))
-
-	var result interface{}
-
-	if validate {
-		validatePackageRequest := &types.ValidatePackageRequest{
-			VersionPackage: createAppRequest.VersionPackage,
-			VersionType:    createAppRequest.VersionType,
-		}
-		result, err = app.ValidatePackage(validatePackageRequest)
-	} else {
-		result, err = app.CreateApp(createAppRequest)
-	}
-
-	if _, notEnabled := err.(client.ClientSetNotEnabledError); notEnabled {
-		resp.WriteHeaderAndEntity(http.StatusNotImplemented, errors.Wrap(err))
-		return
-	}
-
-	if status.Code(err) == codes.InvalidArgument {
-		resp.WriteHeaderAndEntity(http.StatusBadRequest, errors.Wrap(err))
-		return
-	}
-
-	if err != nil {
-		resp.WriteHeaderAndEntity(http.StatusInternalServerError, errors.Wrap(err))
-		return
-	}
-
-	resp.WriteEntity(result)
-}
-
-func CreateAppVersion(req *restful.Request, resp *restful.Response) {
-	var createAppVersionRequest types.CreateAppVersionRequest
-	err := req.ReadEntity(&createAppVersionRequest)
-	if err != nil {
-		resp.WriteHeaderAndEntity(http.StatusBadRequest, errors.Wrap(err))
-		return
-	}
-	// override app id
-	createAppVersionRequest.AppId = req.PathParameter("app")
-	createAppVersionRequest.Username = req.HeaderParameter(constants.UserNameHeader)
-
-	validate, _ := strconv.ParseBool(req.QueryParameter("validate"))
-
-	var result interface{}
-
-	if validate {
-		validatePackageRequest := &types.ValidatePackageRequest{
-			VersionPackage: createAppVersionRequest.Package,
-			VersionType:    createAppVersionRequest.Type,
-		}
-		result, err = app.ValidatePackage(validatePackageRequest)
-	} else {
-		result, err = app.CreateAppVersion(&createAppVersionRequest)
-	}
-
-	if _, notEnabled := err.(client.ClientSetNotEnabledError); notEnabled {
-		resp.WriteHeaderAndEntity(http.StatusNotImplemented, errors.Wrap(err))
-		return
-	}
-
-	if status.Code(err) == codes.InvalidArgument {
-		resp.WriteHeaderAndEntity(http.StatusBadRequest, errors.Wrap(err))
-		return
-	}
-
-	if err != nil {
-		resp.WriteHeaderAndEntity(http.StatusInternalServerError, errors.Wrap(err))
-		return
-	}
-
-	resp.WriteEntity(result)
-}
-
-func ModifyAppVersion(req *restful.Request, resp *restful.Response) {
-
-	var patchAppVersionRequest types.ModifyAppVersionRequest
-	err := req.ReadEntity(&patchAppVersionRequest)
-	versionId := req.PathParameter("version")
-
-	if err != nil {
-		resp.WriteHeaderAndEntity(http.StatusBadRequest, errors.Wrap(err))
-		return
-	}
-
-	err = app.PatchAppVersion(versionId, &patchAppVersionRequest)
-
-	if _, notEnabled := err.(client.ClientSetNotEnabledError); notEnabled {
-		resp.WriteHeaderAndEntity(http.StatusNotImplemented, errors.Wrap(err))
-		return
-	}
-
-	if status.Code(err) == codes.InvalidArgument {
-		resp.WriteHeaderAndEntity(http.StatusBadRequest, errors.Wrap(err))
-		return
-	}
-
-	if err != nil {
-		resp.WriteHeaderAndEntity(http.StatusInternalServerError, errors.Wrap(err))
-		return
-	}
-
-	resp.WriteEntity(errors.None)
-}
-
-func DeleteAppVersion(req *restful.Request, resp *restful.Response) {
-	versionId := req.PathParameter("version")
-
-	err := app.DeleteAppVersion(versionId)
-
-	if _, notEnabled := err.(client.ClientSetNotEnabledError); notEnabled {
-		resp.WriteHeaderAndEntity(http.StatusNotImplemented, errors.Wrap(err))
-		return
-	}
-
-	if status.Code(err) == codes.NotFound {
-		resp.WriteHeaderAndEntity(http.StatusNotFound, errors.Wrap(err))
-		return
-	}
-
-	if err != nil {
-		resp.WriteHeaderAndEntity(http.StatusInternalServerError, errors.Wrap(err))
-		return
-	}
-
-	resp.WriteEntity(errors.None)
-}
-
-func DescribeAppVersion(req *restful.Request, resp *restful.Response) {
-	versionId := req.PathParameter("version")
-
-	result, err := app.DescribeAppVersion(versionId)
-
-	if _, notEnabled := err.(client.ClientSetNotEnabledError); notEnabled {
-		resp.WriteHeaderAndEntity(http.StatusNotImplemented, errors.Wrap(err))
-		return
-	}
-
-	if status.Code(err) == codes.NotFound {
-		resp.WriteHeaderAndEntity(http.StatusNotFound, errors.Wrap(err))
-		return
-	}
-
-	if err != nil {
-		resp.WriteHeaderAndEntity(http.StatusInternalServerError, errors.Wrap(err))
-		return
-	}
-
-	resp.WriteEntity(result)
-}

pkg/apiserver/openpitrix/attachments.go

@@ -1,54 +0,0 @@
-/*
- *
- * Copyright 2019 The KubeSphere Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- * /
- */
-
-package openpitrix
-
-import (
-    "github.com/emicklei/go-restful"
-    "google.golang.org/grpc/codes"
-    "google.golang.org/grpc/status"
-    "kubesphere.io/kubesphere/pkg/models/openpitrix/attachment"
-    "kubesphere.io/kubesphere/pkg/server/errors"
-    "kubesphere.io/kubesphere/pkg/simple/client"
-    "net/http"
-)
-
-func DescribeAttachment(req *restful.Request, resp *restful.Response) {
-	attachmentId := req.PathParameter("attachment")
-	fileName := req.QueryParameter("filename")
-	result, err := attachment.DescribeAttachment(attachmentId)
-	// file raw
-	if fileName != "" {
-		data := result.AttachmentContent[fileName]
-		resp.Write(data)
-		resp.Header().Set("Content-Type", "text/plain")
-		return
-	}
-
-	if _, notEnabled := err.(client.ClientSetNotEnabledError); notEnabled {
-		resp.WriteHeaderAndEntity(http.StatusNotImplemented, errors.Wrap(err))
-		return
-	}
-
-	if status.Code(err) == codes.NotFound {
-		resp.WriteHeaderAndEntity(http.StatusNotFound, errors.Wrap(err))
-		return
-	}
-
-	resp.WriteEntity(result)
-}

pkg/apiserver/openpitrix/categories.go

@@ -1,173 +0,0 @@
-/*
- *
- * Copyright 2019 The KubeSphere Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- * /
- */
-
-package openpitrix
-
-import (
-	"github.com/emicklei/go-restful"
-	"google.golang.org/grpc/codes"
-	"google.golang.org/grpc/status"
-	"k8s.io/klog"
-	"kubesphere.io/kubesphere/pkg/models/openpitrix/app"
-	"kubesphere.io/kubesphere/pkg/models/openpitrix/category"
-	"kubesphere.io/kubesphere/pkg/models/openpitrix/type"
-	"kubesphere.io/kubesphere/pkg/server/errors"
-	"kubesphere.io/kubesphere/pkg/server/params"
-	"kubesphere.io/kubesphere/pkg/simple/client"
-	"net/http"
-	"strconv"
-)
-
-func CreateCategory(req *restful.Request, resp *restful.Response) {
-	createCategoryRequest := &types.CreateCategoryRequest{}
-	err := req.ReadEntity(createCategoryRequest)
-	if err != nil {
-		resp.WriteHeaderAndEntity(http.StatusBadRequest, errors.Wrap(err))
-		return
-	}
-
-	result, err := category.CreateCategory(createCategoryRequest)
-
-	if _, notEnabled := err.(client.ClientSetNotEnabledError); notEnabled {
-		resp.WriteHeaderAndEntity(http.StatusNotImplemented, errors.Wrap(err))
-		return
-	}
-	if status.Code(err) == codes.InvalidArgument {
-		resp.WriteHeaderAndEntity(http.StatusBadRequest, errors.Wrap(err))
-		return
-	}
-	if err != nil {
-		resp.WriteHeaderAndEntity(http.StatusInternalServerError, errors.Wrap(err))
-		return
-	}
-
-	resp.WriteEntity(result)
-}
-func DeleteCategory(req *restful.Request, resp *restful.Response) {
-	categoryId := req.PathParameter("category")
-
-	err := category.DeleteCategory(categoryId)
-
-	if _, notEnabled := err.(client.ClientSetNotEnabledError); notEnabled {
-		resp.WriteHeaderAndEntity(http.StatusNotImplemented, errors.Wrap(err))
-		return
-	}
-	if status.Code(err) == codes.NotFound {
-		resp.WriteHeaderAndEntity(http.StatusNotFound, errors.Wrap(err))
-		return
-	}
-	if err != nil {
-		resp.WriteHeaderAndEntity(http.StatusInternalServerError, errors.Wrap(err))
-		return
-	}
-
-	resp.WriteEntity(errors.None)
-}
-func ModifyCategory(req *restful.Request, resp *restful.Response) {
-	var modifyCategoryRequest types.ModifyCategoryRequest
-	categoryId := req.PathParameter("category")
-	err := req.ReadEntity(&modifyCategoryRequest)
-	if err != nil {
-		resp.WriteHeaderAndEntity(http.StatusBadRequest, errors.Wrap(err))
-		return
-	}
-
-	err = category.PatchCategory(categoryId, &modifyCategoryRequest)
-
-	if _, notEnabled := err.(client.ClientSetNotEnabledError); notEnabled {
-		resp.WriteHeaderAndEntity(http.StatusNotImplemented, errors.Wrap(err))
-		return
-	}
-	if status.Code(err) == codes.InvalidArgument {
-		resp.WriteHeaderAndEntity(http.StatusBadRequest, errors.Wrap(err))
-		return
-	}
-	if err != nil {
-		resp.WriteHeaderAndEntity(http.StatusInternalServerError, errors.Wrap(err))
-		return
-	}
-
-	resp.WriteEntity(errors.None)
-}
-func DescribeCategory(req *restful.Request, resp *restful.Response) {
-	categoryId := req.PathParameter("category")
-
-	result, err := category.DescribeCategory(categoryId)
-
-	if _, notEnabled := err.(client.ClientSetNotEnabledError); notEnabled {
-		resp.WriteHeaderAndEntity(http.StatusNotImplemented, errors.Wrap(err))
-		return
-	}
-
-	if status.Code(err) == codes.NotFound {
-		resp.WriteHeaderAndEntity(http.StatusNotFound, errors.Wrap(err))
-		return
-	}
-
-	if err != nil {
-		resp.WriteHeaderAndEntity(http.StatusInternalServerError, errors.Wrap(err))
-		return
-	}
-
-	resp.WriteEntity(result)
-}
-func ListCategories(req *restful.Request, resp *restful.Response) {
-	conditions, err := params.ParseConditions(req.QueryParameter(params.ConditionsParam))
-	orderBy := req.QueryParameter(params.OrderByParam)
-	limit, offset := params.ParsePaging(req.QueryParameter(params.PagingParam))
-	reverse := params.ParseReverse(req)
-	if orderBy == "" {
-		orderBy = "create_time"
-		reverse = true
-	}
-	statistics, _ := strconv.ParseBool(req.QueryParameter("statistics"))
-
-	if err != nil {
-		resp.WriteHeaderAndEntity(http.StatusBadRequest, errors.Wrap(err))
-		return
-	}
-
-	result, err := category.ListCategories(conditions, orderBy, reverse, limit, offset)
-
-	if _, notEnabled := err.(client.ClientSetNotEnabledError); notEnabled {
-		resp.WriteHeaderAndEntity(http.StatusNotImplemented, errors.Wrap(err))
-		return
-	}
-
-	if err != nil {
-		klog.Errorln(err)
-		resp.WriteHeaderAndEntity(http.StatusInternalServerError, errors.Wrap(err))
-		return
-	}
-
-	if statistics {
-		for _, item := range result.Items {
-			if category, ok := item.(*types.Category); ok {
-				statisticsResult, err := app.ListApps(&params.Conditions{Match: map[string]string{"category_id": category.CategoryID, "status": app.StatusActive, "repo": app.BuiltinRepoId}}, "", false, 0, 0)
-				if err != nil {
-					klog.Errorln(err)
-					resp.WriteHeaderAndEntity(http.StatusInternalServerError, errors.Wrap(err))
-					return
-				}
-				category.AppTotal = &statisticsResult.TotalCount
-			}
-		}
-	}
-
-	resp.WriteEntity(result)
-}

pkg/apiserver/openpitrix/repos.go

@@ -1,223 +0,0 @@
-/*
- *
- * Copyright 2019 The KubeSphere Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- * /
- */
-
-package openpitrix
-
-import (
-	"github.com/emicklei/go-restful"
-	"google.golang.org/grpc/codes"
-	"google.golang.org/grpc/status"
-	"k8s.io/klog"
-	"kubesphere.io/kubesphere/pkg/models/openpitrix/repo"
-	"kubesphere.io/kubesphere/pkg/models/openpitrix/type"
-	"kubesphere.io/kubesphere/pkg/server/errors"
-	"kubesphere.io/kubesphere/pkg/server/params"
-	"kubesphere.io/kubesphere/pkg/simple/client"
-	"net/http"
-	"strconv"
-)
-
-func CreateRepo(req *restful.Request, resp *restful.Response) {
-	createRepoRequest := &types.CreateRepoRequest{}
-	err := req.ReadEntity(createRepoRequest)
-	if err != nil {
-		resp.WriteHeaderAndEntity(http.StatusBadRequest, errors.Wrap(err))
-		return
-	}
-	validate, _ := strconv.ParseBool(req.QueryParameter("validate"))
-
-	var result interface{}
-
-	if validate {
-		validateRepoRequest := &types.ValidateRepoRequest{
-			Type:       createRepoRequest.Type,
-			Url:        createRepoRequest.URL,
-			Credential: createRepoRequest.Credential,
-		}
-		result, err = repo.ValidateRepo(validateRepoRequest)
-	} else {
-		result, err = repo.CreateRepo(createRepoRequest)
-	}
-
-	if _, notEnabled := err.(client.ClientSetNotEnabledError); notEnabled {
-		resp.WriteHeaderAndEntity(http.StatusNotImplemented, errors.Wrap(err))
-		return
-	}
-	if status.Code(err) == codes.InvalidArgument {
-		resp.WriteHeaderAndEntity(http.StatusBadRequest, errors.Wrap(err))
-		return
-	}
-	if err != nil {
-		resp.WriteHeaderAndEntity(http.StatusInternalServerError, errors.Wrap(err))
-		return
-	}
-
-	resp.WriteEntity(result)
-}
-
-func DoRepoAction(req *restful.Request, resp *restful.Response) {
-	repoActionRequest := &types.RepoActionRequest{}
-	repoId := req.PathParameter("repo")
-	err := req.ReadEntity(repoActionRequest)
-	if err != nil {
-		resp.WriteHeaderAndEntity(http.StatusBadRequest, errors.Wrap(err))
-		return
-	}
-
-	err = repo.DoRepoAction(repoId, repoActionRequest)
-
-	if _, notEnabled := err.(client.ClientSetNotEnabledError); notEnabled {
-		resp.WriteHeaderAndEntity(http.StatusNotImplemented, errors.Wrap(err))
-		return
-	}
-	if status.Code(err) == codes.InvalidArgument {
-		resp.WriteHeaderAndEntity(http.StatusBadRequest, errors.Wrap(err))
-		return
-	}
-	if err != nil {
-		resp.WriteHeaderAndEntity(http.StatusInternalServerError, errors.Wrap(err))
-		return
-	}
-
-	resp.WriteEntity(errors.None)
-}
-
-func DeleteRepo(req *restful.Request, resp *restful.Response) {
-	repoId := req.PathParameter("repo")
-
-	err := repo.DeleteRepo(repoId)
-
-	if _, notEnabled := err.(client.ClientSetNotEnabledError); notEnabled {
-		resp.WriteHeaderAndEntity(http.StatusNotImplemented, errors.Wrap(err))
-		return
-	}
-	if status.Code(err) == codes.NotFound {
-		resp.WriteHeaderAndEntity(http.StatusNotFound, errors.Wrap(err))
-		return
-	}
-	if err != nil {
-		resp.WriteHeaderAndEntity(http.StatusInternalServerError, errors.Wrap(err))
-		return
-	}
-
-	resp.WriteEntity(errors.None)
-}
-
-func ModifyRepo(req *restful.Request, resp *restful.Response) {
-	var updateRepoRequest types.ModifyRepoRequest
-	repoId := req.PathParameter("repo")
-	err := req.ReadEntity(&updateRepoRequest)
-	if err != nil {
-		resp.WriteHeaderAndEntity(http.StatusBadRequest, errors.Wrap(err))
-		return
-	}
-
-	err = repo.PatchRepo(repoId, &updateRepoRequest)
-
-	if _, notEnabled := err.(client.ClientSetNotEnabledError); notEnabled {
-		resp.WriteHeaderAndEntity(http.StatusNotImplemented, errors.Wrap(err))
-		return
-	}
-	if status.Code(err) == codes.InvalidArgument {
-		resp.WriteHeaderAndEntity(http.StatusBadRequest, errors.Wrap(err))
-		return
-	}
-	if err != nil {
-		resp.WriteHeaderAndEntity(http.StatusInternalServerError, errors.Wrap(err))
-		return
-	}
-
-	resp.WriteEntity(errors.None)
-}
-
-func DescribeRepo(req *restful.Request, resp *restful.Response) {
-	repoId := req.PathParameter("repo")
-
-	result, err := repo.DescribeRepo(repoId)
-
-	if _, notEnabled := err.(client.ClientSetNotEnabledError); notEnabled {
-		resp.WriteHeaderAndEntity(http.StatusNotImplemented, errors.Wrap(err))
-		return
-	}
-	if status.Code(err) == codes.NotFound {
-		resp.WriteHeaderAndEntity(http.StatusNotFound, errors.Wrap(err))
-		return
-	}
-	if err != nil {
-		resp.WriteHeaderAndEntity(http.StatusInternalServerError, errors.Wrap(err))
-		return
-	}
-
-	resp.WriteEntity(result)
-}
-func ListRepos(req *restful.Request, resp *restful.Response) {
-	conditions, err := params.ParseConditions(req.QueryParameter(params.ConditionsParam))
-	orderBy := req.QueryParameter(params.OrderByParam)
-	limit, offset := params.ParsePaging(req.QueryParameter(params.PagingParam))
-	reverse := params.ParseReverse(req)
-	if orderBy == "" {
-		orderBy = "create_time"
-		reverse = true
-	}
-
-	if err != nil {
-		resp.WriteHeaderAndEntity(http.StatusBadRequest, errors.Wrap(err))
-		return
-	}
-
-	result, err := repo.ListRepos(conditions, orderBy, reverse, limit, offset)
-
-	if _, notEnabled := err.(client.ClientSetNotEnabledError); notEnabled {
-		resp.WriteHeaderAndEntity(http.StatusNotImplemented, errors.Wrap(err))
-		return
-	}
-
-	if err != nil {
-		klog.Errorln(err)
-		resp.WriteHeaderAndEntity(http.StatusInternalServerError, errors.Wrap(err))
-		return
-	}
-
-	resp.WriteEntity(result)
-}
-
-func ListRepoEvents(req *restful.Request, resp *restful.Response) {
-	repoId := req.PathParameter("repo")
-	conditions, err := params.ParseConditions(req.QueryParameter(params.ConditionsParam))
-	limit, offset := params.ParsePaging(req.QueryParameter(params.PagingParam))
-
-	if err != nil {
-		resp.WriteHeaderAndEntity(http.StatusBadRequest, errors.Wrap(err))
-		return
-	}
-
-	result, err := repo.ListRepoEvents(repoId, conditions, limit, offset)
-
-	if _, notEnabled := err.(client.ClientSetNotEnabledError); notEnabled {
-		resp.WriteHeaderAndEntity(http.StatusNotImplemented, errors.Wrap(err))
-		return
-	}
-
-	if err != nil {
-		klog.Errorln(err)
-		resp.WriteHeaderAndEntity(http.StatusInternalServerError, errors.Wrap(err))
-		return
-	}
-
-	resp.WriteEntity(result)
-}

pkg/apiserver/tenant/tenant.go

@@ -1,440 +0,0 @@
-/*
-
- Copyright 2019 The KubeSphere Authors.
-
- Licensed under the Apache License, Version 2.0 (the "License");
- you may not use this file except in compliance with the License.
- You may obtain a copy of the License at
-
-     http://www.apache.org/licenses/LICENSE-2.0
-
- Unless required by applicable law or agreed to in writing, software
- distributed under the License is distributed on an "AS IS" BASIS,
- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- See the License for the specific language governing permissions and
- limitations under the License.
-
-*/
-package tenant
-
-import (
-	"github.com/emicklei/go-restful"
-	"k8s.io/api/core/v1"
-	rbacv1 "k8s.io/api/rbac/v1"
-	k8serr "k8s.io/apimachinery/pkg/api/errors"
-	"k8s.io/apimachinery/pkg/util/net"
-	"k8s.io/klog"
-	devopsv1alpha2 "kubesphere.io/kubesphere/pkg/api/devops/v1alpha2"
-	loggingv1alpha2 "kubesphere.io/kubesphere/pkg/api/logging/v1alpha2"
-	"kubesphere.io/kubesphere/pkg/apis/tenant/v1alpha1"
-	"kubesphere.io/kubesphere/pkg/apiserver/logging"
-	"kubesphere.io/kubesphere/pkg/constants"
-	"kubesphere.io/kubesphere/pkg/models/iam"
-	"kubesphere.io/kubesphere/pkg/models/metrics"
-	"kubesphere.io/kubesphere/pkg/models/resources/v1alpha2"
-	"kubesphere.io/kubesphere/pkg/models/tenant"
-	"kubesphere.io/kubesphere/pkg/models/workspaces"
-	"kubesphere.io/kubesphere/pkg/server/errors"
-	"kubesphere.io/kubesphere/pkg/server/params"
-
-	"kubesphere.io/kubesphere/pkg/utils/sliceutil"
-	"net/http"
-	"strings"
-)
-
-func ListWorkspaceRules(req *restful.Request, resp *restful.Response) {
-	workspace := req.PathParameter("workspace")
-	username := req.HeaderParameter(constants.UserNameHeader)
-
-	rules, err := iam.GetUserWorkspaceSimpleRules(workspace, username)
-
-	if err != nil {
-		resp.WriteHeaderAndEntity(http.StatusInternalServerError, errors.Wrap(err))
-		return
-	}
-
-	resp.WriteAsJson(rules)
-}
-
-func ListWorkspaces(req *restful.Request, resp *restful.Response) {
-	username := req.HeaderParameter(constants.UserNameHeader)
-	conditions, err := params.ParseConditions(req.QueryParameter(params.ConditionsParam))
-	orderBy := req.QueryParameter(params.OrderByParam)
-	limit, offset := params.ParsePaging(req.QueryParameter(params.PagingParam))
-	reverse := params.ParseReverse(req)
-
-	if orderBy == "" {
-		orderBy = v1alpha2.CreateTime
-		reverse = true
-	}
-
-	if err != nil {
-		resp.WriteHeaderAndEntity(http.StatusBadRequest, errors.Wrap(err))
-		return
-	}
-
-	result, err := tenant.ListWorkspaces(username, conditions, orderBy, reverse, limit, offset)
-
-	if err != nil {
-		resp.WriteHeaderAndEntity(http.StatusInternalServerError, errors.Wrap(err))
-		return
-	}
-
-	resp.WriteAsJson(result)
-}
-
-func DescribeWorkspace(req *restful.Request, resp *restful.Response) {
-	username := req.HeaderParameter(constants.UserNameHeader)
-	workspaceName := req.PathParameter("workspace")
-
-	result, err := tenant.DescribeWorkspace(username, workspaceName)
-
-	if err != nil {
-		klog.Errorf("describe workspace failed: %+v", err)
-		if k8serr.IsNotFound(err) {
-			resp.WriteHeaderAndEntity(http.StatusNotFound, errors.Wrap(err))
-		} else {
-			resp.WriteHeaderAndEntity(http.StatusInternalServerError, errors.Wrap(err))
-		}
-		return
-	}
-
-	resp.WriteAsJson(result)
-}
-func ListNamespacesByUsername(req *restful.Request, resp *restful.Response) {
-	ListNamespaces(req, resp)
-}
-
-func ListNamespaces(req *restful.Request, resp *restful.Response) {
-	workspace := req.PathParameter("workspace")
-	username := req.PathParameter("member")
-	// /workspaces/{workspace}/members/{username}/namespaces
-	if username == "" {
-		// /workspaces/{workspace}/namespaces
-		username = req.HeaderParameter(constants.UserNameHeader)
-	}
-
-	conditions, err := params.ParseConditions(req.QueryParameter(params.ConditionsParam))
-	orderBy := req.QueryParameter(params.OrderByParam)
-	limit, offset := params.ParsePaging(req.QueryParameter(params.PagingParam))
-	reverse := params.ParseReverse(req)
-
-	if err != nil {
-		resp.WriteHeaderAndEntity(http.StatusBadRequest, errors.Wrap(err))
-		return
-	}
-
-	conditions.Match[constants.WorkspaceLabelKey] = workspace
-
-	result, err := tenant.ListNamespaces(username, conditions, orderBy, reverse, limit, offset)
-
-	if err != nil {
-		resp.WriteHeaderAndEntity(http.StatusInternalServerError, errors.Wrap(err))
-		return
-	}
-
-	namespaces := make([]*v1.Namespace, 0)
-
-	for _, item := range result.Items {
-		namespaces = append(namespaces, item.(*v1.Namespace).DeepCopy())
-	}
-
-	namespaces = metrics.GetNamespacesWithMetrics(namespaces)
-
-	items := make([]interface{}, 0)
-
-	for _, item := range namespaces {
-		items = append(items, item)
-	}
-
-	result.Items = items
-
-	resp.WriteAsJson(result)
-}
-
-func CreateNamespace(req *restful.Request, resp *restful.Response) {
-	workspaceName := req.PathParameter("workspace")
-	username := req.HeaderParameter(constants.UserNameHeader)
-	var namespace v1.Namespace
-	err := req.ReadEntity(&namespace)
-	if err != nil {
-		resp.WriteHeaderAndEntity(http.StatusBadRequest, errors.Wrap(err))
-		return
-	}
-
-	workspace, err := tenant.GetWorkspace(workspaceName)
-
-	err = checkResourceQuotas(workspace)
-
-	if err != nil {
-		resp.WriteHeaderAndEntity(http.StatusForbidden, errors.Wrap(err))
-		return
-	}
-
-	if err != nil {
-		if k8serr.IsNotFound(err) {
-			resp.WriteHeaderAndEntity(http.StatusForbidden, errors.Wrap(err))
-		} else {
-			resp.WriteHeaderAndEntity(http.StatusInternalServerError, errors.Wrap(err))
-		}
-		return
-	}
-
-	created, err := tenant.CreateNamespace(workspaceName, &namespace, username)
-
-	if err != nil {
-		if k8serr.IsAlreadyExists(err) {
-			resp.WriteHeaderAndEntity(http.StatusConflict, err)
-		} else {
-			resp.WriteHeaderAndEntity(http.StatusInternalServerError, err)
-		}
-		return
-	}
-	resp.WriteAsJson(created)
-}
-
-func DeleteNamespace(req *restful.Request, resp *restful.Response) {
-	workspaceName := req.PathParameter("workspace")
-	namespaceName := req.PathParameter("namespace")
-
-	err := workspaces.DeleteNamespace(workspaceName, namespaceName)
-
-	if err != nil {
-		resp.WriteHeaderAndEntity(http.StatusBadRequest, errors.Wrap(err))
-		return
-	}
-
-	resp.WriteAsJson(errors.None)
-}
-
-func checkResourceQuotas(wokrspace *v1alpha1.Workspace) error {
-	return nil
-}
-
-func ListDevopsProjectsByUsername(req *restful.Request, resp *restful.Response) {
-	ListDevopsProjects(req, resp)
-}
-
-func ListDevopsProjects(req *restful.Request, resp *restful.Response) {
-
-	workspace := req.PathParameter("workspace")
-	username := req.PathParameter("member")
-	if username == "" {
-		username = req.HeaderParameter(constants.UserNameHeader)
-	}
-	orderBy := req.QueryParameter(params.OrderByParam)
-	reverse := params.ParseReverse(req)
-	limit, offset := params.ParsePaging(req.QueryParameter(params.PagingParam))
-	conditions, err := params.ParseConditions(req.QueryParameter(params.ConditionsParam))
-
-	if err != nil {
-		klog.Errorf("%+v", err)
-		errors.ParseSvcErr(restful.NewError(http.StatusBadRequest, err.Error()), resp)
-		return
-	}
-
-	result, err := tenant.ListDevopsProjects(workspace, username, conditions, orderBy, reverse, limit, offset)
-
-	if err != nil {
-		klog.Errorf("%+v", err)
-		errors.ParseSvcErr(err, resp)
-		return
-	}
-
-	resp.WriteAsJson(result)
-}
-
-func GetDevOpsProjectsCount(req *restful.Request, resp *restful.Response) {
-	username := req.HeaderParameter(constants.UserNameHeader)
-
-	result, err := tenant.GetDevOpsProjectsCount(username)
-	if err != nil {
-		klog.Errorf("%+v", err)
-		errors.ParseSvcErr(err, resp)
-		return
-	}
-	resp.WriteAsJson(struct {
-		Count uint32 `json:"count"`
-	}{Count: result})
-}
-func DeleteDevopsProject(req *restful.Request, resp *restful.Response) {
-	projectId := req.PathParameter("devops")
-	workspaceName := req.PathParameter("workspace")
-	username := req.HeaderParameter(constants.UserNameHeader)
-
-	_, err := tenant.GetWorkspace(workspaceName)
-
-	if err != nil {
-		klog.Errorf("%+v", err)
-		errors.ParseSvcErr(restful.NewError(http.StatusBadRequest, err.Error()), resp)
-		return
-	}
-
-	err = tenant.DeleteDevOpsProject(projectId, username)
-
-	if err != nil {
-		klog.Errorf("%+v", err)
-		errors.ParseSvcErr(err, resp)
-		return
-	}
-
-	resp.WriteAsJson(errors.None)
-}
-
-func CreateDevopsProject(req *restful.Request, resp *restful.Response) {
-
-	workspaceName := req.PathParameter("workspace")
-	username := req.HeaderParameter(constants.UserNameHeader)
-
-	var devops devopsv1alpha2.DevOpsProject
-
-	err := req.ReadEntity(&devops)
-
-	if err != nil {
-		klog.Infof("%+v", err)
-		errors.ParseSvcErr(restful.NewError(http.StatusBadRequest, err.Error()), resp)
-		return
-	}
-
-	klog.Infoln("create workspace", username, workspaceName, devops)
-	project, err := tenant.CreateDevopsProject(username, workspaceName, &devops)
-
-	if err != nil {
-		klog.Errorf("%+v", err)
-		errors.ParseSvcErr(err, resp)
-		return
-	}
-
-	resp.WriteAsJson(project)
-}
-
-func ListNamespaceRules(req *restful.Request, resp *restful.Response) {
-	namespace := req.PathParameter("namespace")
-	username := req.HeaderParameter(constants.UserNameHeader)
-
-	rules, err := iam.GetUserNamespaceSimpleRules(namespace, username)
-
-	if err != nil {
-		resp.WriteError(http.StatusInternalServerError, err)
-		return
-	}
-
-	resp.WriteAsJson(rules)
-}
-
-func ListDevopsRules(req *restful.Request, resp *restful.Response) {
-
-	devops := req.PathParameter("devops")
-	username := req.HeaderParameter(constants.UserNameHeader)
-
-	rules, err := tenant.GetUserDevopsSimpleRules(username, devops)
-
-	if err != nil {
-		klog.Errorf("%+v", err)
-		errors.ParseSvcErr(err, resp)
-		return
-	}
-
-	resp.WriteAsJson(rules)
-}
-
-func LogQuery(req *restful.Request, resp *restful.Response) {
-	operation := req.QueryParameter("operation")
-	req, err := regenerateLoggingRequest(req)
-	switch {
-	case err != nil:
-		resp.WriteHeaderAndEntity(http.StatusInternalServerError, errors.Wrap(err))
-	case req != nil:
-		logging.LoggingQueryCluster(req, resp)
-	default:
-		if operation == "export" {
-			resp.Header().Set(restful.HEADER_ContentType, "text/plain")
-			resp.Header().Set("Content-Disposition", "attachment")
-			resp.Write(nil)
-		} else {
-			resp.WriteAsJson(loggingv1alpha2.QueryResult{Read: new(loggingv1alpha2.ReadResult)})
-		}
-	}
-}
-
-// override namespace query conditions
-func regenerateLoggingRequest(req *restful.Request) (*restful.Request, error) {
-
-	username := req.HeaderParameter(constants.UserNameHeader)
-
-	// regenerate the request for log query
-	newUrl := net.FormatURL("http", "127.0.0.1", 80, "/kapis/logging.kubesphere.io/v1alpha2/cluster")
-	values := req.Request.URL.Query()
-
-	clusterRules, err := iam.GetUserClusterRules(username)
-	if err != nil {
-		klog.Errorln(err)
-		return nil, err
-	}
-
-	hasClusterLogAccess := iam.RulesMatchesRequired(clusterRules, rbacv1.PolicyRule{Verbs: []string{"get"}, Resources: []string{"*"}, APIGroups: []string{"logging.kubesphere.io"}})
-	// if the user is not a cluster admin
-	if !hasClusterLogAccess {
-		queryNamespaces := strings.Split(req.QueryParameter("namespaces"), ",")
-		// then the user can only view logs of namespaces he belongs to
-		namespaces := make([]string, 0)
-		roles, err := iam.GetUserRoles("", username)
-		if err != nil {
-			klog.Errorln(err)
-			return nil, err
-		}
-		for _, role := range roles {
-			if !sliceutil.HasString(namespaces, role.Namespace) && iam.RulesMatchesRequired(role.Rules, rbacv1.PolicyRule{Verbs: []string{"get"}, Resources: []string{"*"}, APIGroups: []string{"logging.kubesphere.io"}}) {
-				namespaces = append(namespaces, role.Namespace)
-			}
-		}
-
-		// if the user belongs to no namespace
-		// then no log visible
-		if len(namespaces) == 0 {
-			return nil, nil
-		} else if len(queryNamespaces) == 1 && queryNamespaces[0] == "" {
-			values.Set("namespaces", strings.Join(namespaces, ","))
-		} else {
-			inter := intersection(queryNamespaces, namespaces)
-			if len(inter) == 0 {
-				return nil, nil
-			}
-			values.Set("namespaces", strings.Join(inter, ","))
-		}
-	}
-
-	newUrl.RawQuery = values.Encode()
-
-	// forward the request to logging model
-	newHttpRequest, _ := http.NewRequest(http.MethodGet, newUrl.String(), nil)
-	return restful.NewRequest(newHttpRequest), nil
-}
-
-func intersection(s1, s2 []string) (inter []string) {
-	hash := make(map[string]bool)
-	for _, e := range s1 {
-		hash[e] = true
-	}
-	for _, e := range s2 {
-		// If elements present in the hashmap then append intersection list.
-		if hash[e] {
-			inter = append(inter, e)
-		}
-	}
-	//Remove dups from slice.
-	inter = removeDups(inter)
-	return
-}
-
-//Remove dups from slice.
-func removeDups(elements []string) (nodups []string) {
-	encountered := make(map[string]bool)
-	for _, element := range elements {
-		if !encountered[element] {
-			nodups = append(nodups, element)
-			encountered[element] = true
-		}
-	}
-	return
-}