migrate legacy API

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

pkg/models/resources/v1alpha2/interface.go

@@ -81,6 +81,13 @@ func ObjectMetaExactlyMath(key, value string, item metav1.ObjectMeta) bool {
 		if !strings.Contains(item.Name, value) && !FuzzyMatch(item.Labels, "", value) && !FuzzyMatch(item.Annotations, "", value) {
 			return false
 		}
+	case Owner:
+		for _, ownerReference := range item.OwnerReferences {
+			if strings.Compare(string(ownerReference.UID), value) == 0 {
+				return true
+			}
+		}
+		return false
 	default:
 		// label not exist or value not equal
 		if val, ok := item.Labels[key]; !ok || val != value {
@@ -109,13 +116,6 @@ func ObjectMetaFuzzyMath(key, value string, item metav1.ObjectMeta) bool {
 		if !strings.Contains(item.Labels[Chart], value) && !strings.Contains(item.Labels[Release], value) {
 			return false
 		}
-	case Owner:
-		for _, ownerReference := range item.OwnerReferences {
-			if strings.Compare(string(ownerReference.UID), value) == 0 {
-				return true
-			}
-		}
-		return false
 	default:
 		if !FuzzyMatch(item.Labels, key, value) {
 			return false

pkg/models/resources/v1alpha2/resource/resources.go

@@ -115,7 +115,7 @@ func (r *ResourceGetter) ListResources(namespace, resource string, conditions *p
 
 	// none namespace resource
 	if namespace != "" && sliceutil.HasString(clusterResources, resource) {
-		err = fmt.Errorf("namespaced resource %s not found", resource)
+		err = fmt.Errorf("resource %s is not supported", resource)
 		klog.Errorln(err)
 		return nil, err
 	}
@@ -123,7 +123,7 @@ func (r *ResourceGetter) ListResources(namespace, resource string, conditions *p
 	if searcher, ok := r.resourcesGetters[resource]; ok {
 		result, err = searcher.Search(namespace, conditions, orderBy, reverse)
 	} else {
-		err = fmt.Errorf("namespaced resource %s not found", resource)
+		err = fmt.Errorf("resource %s is not supported", resource)
 		klog.Errorln(err)
 		return nil, err
 	}

pkg/models/resources/v1alpha3/application/applications.go

@@ -20,11 +20,11 @@ package application
 import (
 	appv1beta1 "github.com/kubernetes-sigs/application/pkg/apis/app/v1beta1"
 	"github.com/kubernetes-sigs/application/pkg/client/informers/externalversions"
-	"k8s.io/apimachinery/pkg/labels"
 	"k8s.io/apimachinery/pkg/runtime"
 	"kubesphere.io/kubesphere/pkg/api"
 	"kubesphere.io/kubesphere/pkg/apiserver/query"
 	"kubesphere.io/kubesphere/pkg/models/resources/v1alpha3"
+	"time"
 )
 
 type applicationsGetter struct {
@@ -40,7 +40,7 @@ func (d *applicationsGetter) Get(namespace, name string) (runtime.Object, error)
 }
 
 func (d *applicationsGetter) List(namespace string, query *query.Query) (*api.ListResult, error) {
-	all, err := d.informer.App().V1beta1().Applications().Lister().Applications(namespace).List(labels.Everything())
+	all, err := d.informer.App().V1beta1().Applications().Lister().Applications(namespace).List(query.Selector())
 	if err != nil {
 		return nil, err
 	}
@@ -64,8 +64,14 @@ func (d *applicationsGetter) compare(left runtime.Object, right runtime.Object,
 	if !ok {
 		return false
 	}
-
-	return v1alpha3.DefaultObjectMetaCompare(leftApplication.ObjectMeta, rightApplication.ObjectMeta, field)
+	switch field {
+	case query.FieldUpdateTime:
+		fallthrough
+	case query.FieldLastUpdateTimestamp:
+		return lastUpdateTime(leftApplication).After(lastUpdateTime(rightApplication))
+	default:
+		return v1alpha3.DefaultObjectMetaCompare(leftApplication.ObjectMeta, rightApplication.ObjectMeta, field)
+	}
 }
 
 func (d *applicationsGetter) filter(object runtime.Object, filter query.Filter) bool {
@@ -76,3 +82,13 @@ func (d *applicationsGetter) filter(object runtime.Object, filter query.Filter)
 
 	return v1alpha3.DefaultObjectMetaFilter(application.ObjectMeta, filter)
 }
+
+func lastUpdateTime(deployment *appv1beta1.Application) time.Time {
+	lut := deployment.CreationTimestamp.Time
+	for _, condition := range deployment.Status.Conditions {
+		if condition.LastUpdateTime.After(lut) {
+			lut = condition.LastUpdateTime.Time
+		}
+	}
+	return lut
+}

pkg/models/resources/v1alpha3/application/applications_test.go

@@ -59,12 +59,7 @@ func TestListApplications(t *testing.T) {
 				},
 				SortBy:    query.FieldName,
 				Ascending: false,
-				Filters: []query.Filter{
-					{
-						Field: query.FieldNamespace,
-						Value: query.Value("bar2"),
-					},
-				},
+				Filters:   map[query.Field]query.Value{query.FieldNamespace: query.Value("bar2")},
 			},
 			api.ListResult{
 				Items: []interface{}{

pkg/models/resources/v1alpha3/clusterrole/clusterroles.go

@@ -0,0 +1,79 @@
+/*
+
+ 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 clusterrole
+
+import (
+	rbacv1 "k8s.io/api/rbac/v1"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/client-go/informers"
+	"kubesphere.io/kubesphere/pkg/api"
+	"kubesphere.io/kubesphere/pkg/apiserver/query"
+	"kubesphere.io/kubesphere/pkg/models/resources/v1alpha3"
+)
+
+type rolesGetter struct {
+	sharedInformers informers.SharedInformerFactory
+}
+
+func New(sharedInformers informers.SharedInformerFactory) v1alpha3.Interface {
+	return &rolesGetter{sharedInformers: sharedInformers}
+}
+
+func (d *rolesGetter) Get(namespace, name string) (runtime.Object, error) {
+	return d.sharedInformers.Rbac().V1().ClusterRoles().Lister().Get(name)
+}
+
+func (d *rolesGetter) List(namespace string, query *query.Query) (*api.ListResult, error) {
+
+	all, err := d.sharedInformers.Rbac().V1().ClusterRoles().Lister().List(query.Selector())
+	if err != nil {
+		return nil, err
+	}
+
+	var result []runtime.Object
+	for _, deploy := range all {
+		result = append(result, deploy)
+	}
+
+	return v1alpha3.DefaultList(result, query, d.compare, d.filter), nil
+}
+
+func (d *rolesGetter) compare(left runtime.Object, right runtime.Object, field query.Field) bool {
+
+	leftRole, ok := left.(*rbacv1.ClusterRole)
+	if !ok {
+		return false
+	}
+
+	rightRole, ok := right.(*rbacv1.ClusterRole)
+	if !ok {
+		return false
+	}
+
+	return v1alpha3.DefaultObjectMetaCompare(leftRole.ObjectMeta, rightRole.ObjectMeta, field)
+}
+
+func (d *rolesGetter) filter(object runtime.Object, filter query.Filter) bool {
+	role, ok := object.(*rbacv1.ClusterRole)
+
+	if !ok {
+		return false
+	}
+
+	return v1alpha3.DefaultObjectMetaFilter(role.ObjectMeta, filter)
+}

pkg/models/resources/v1alpha3/clusterrole/clusterroles_test.go

@@ -0,0 +1,94 @@
+package clusterrole
+
+import (
+	"github.com/google/go-cmp/cmp"
+	rbacv1 "k8s.io/api/rbac/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/client-go/informers"
+	"k8s.io/client-go/kubernetes/fake"
+	"kubesphere.io/kubesphere/pkg/api"
+	"kubesphere.io/kubesphere/pkg/apiserver/query"
+	"kubesphere.io/kubesphere/pkg/models/resources/v1alpha3"
+	"testing"
+)
+
+func TestListClusterRoles(t *testing.T) {
+	tests := []struct {
+		description string
+		namespace   string
+		query       *query.Query
+		expected    *api.ListResult
+		expectedErr error
+	}{
+		{
+			"test name filter",
+			"bar",
+			&query.Query{
+				Pagination: &query.Pagination{
+					Limit:  1,
+					Offset: 0,
+				},
+				SortBy:    query.FieldName,
+				Ascending: false,
+				Filters:   map[query.Field]query.Value{query.FieldName: query.Value("foo2")},
+			},
+			&api.ListResult{
+				Items: []interface{}{
+					foo2,
+				},
+				TotalItems: 1,
+			},
+			nil,
+		},
+	}
+
+	getter := prepare()
+
+	for _, test := range tests {
+		t.Run(test.description, func(t *testing.T) {
+
+			got, err := getter.List(test.namespace, test.query)
+
+			if test.expectedErr != nil && err != test.expectedErr {
+				t.Errorf("expected error, got nothing")
+			} else if err != nil {
+				t.Fatal(err)
+			}
+
+			if diff := cmp.Diff(got, test.expected); diff != "" {
+				t.Errorf("%T differ (-got, +want): %s", test.expected, diff)
+			}
+		})
+	}
+}
+
+var (
+	foo1 = &rbacv1.ClusterRole{
+		ObjectMeta: metav1.ObjectMeta{
+			Name: "foo1",
+		},
+	}
+
+	foo2 = &rbacv1.ClusterRole{
+		ObjectMeta: metav1.ObjectMeta{
+			Name: "foo2",
+		},
+	}
+	bar1 = &rbacv1.ClusterRole{
+		ObjectMeta: metav1.ObjectMeta{
+			Name: "bar1",
+		},
+	}
+
+	roles = []interface{}{foo1, foo2, bar1}
+)
+
+func prepare() v1alpha3.Interface {
+	client := fake.NewSimpleClientset()
+	informer := informers.NewSharedInformerFactory(client, 0)
+
+	for _, role := range roles {
+		informer.Rbac().V1().ClusterRoles().Informer().GetIndexer().Add(role)
+	}
+	return New(informer)
+}

pkg/models/resources/v1alpha3/configmap/configmaps.go

@@ -19,7 +19,6 @@ package configmap
 
 import (
 	corev1 "k8s.io/api/core/v1"
-	"k8s.io/apimachinery/pkg/labels"
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/client-go/informers"
 	"kubesphere.io/kubesphere/pkg/api"
@@ -40,7 +39,7 @@ func (d *configmapsGetter) Get(namespace, name string) (runtime.Object, error) {
 }
 
 func (d *configmapsGetter) List(namespace string, query *query.Query) (*api.ListResult, error) {
-	all, err := d.informer.Core().V1().ConfigMaps().Lister().ConfigMaps(namespace).List(labels.Everything())
+	all, err := d.informer.Core().V1().ConfigMaps().Lister().ConfigMaps(namespace).List(query.Selector())
 	if err != nil {
 		return nil, err
 	}

pkg/models/resources/v1alpha3/configmap/configmaps_test.go

@@ -30,12 +30,7 @@ func TestListConfigMaps(t *testing.T) {
 				},
 				SortBy:    query.FieldName,
 				Ascending: false,
-				Filters: []query.Filter{
-					{
-						Field: query.FieldNamespace,
-						Value: query.Value("default"),
-					},
-				},
+				Filters:   map[query.Field]query.Value{query.FieldNamespace: query.Value("default")},
 			},
 			&api.ListResult{
 				Items:      []interface{}{foo3, foo2, foo1},

pkg/models/resources/v1alpha3/deployment/deployments.go

@@ -26,8 +26,6 @@ import (
 	"strings"
 	"time"
 
-	"k8s.io/apimachinery/pkg/labels"
-
 	"k8s.io/api/apps/v1"
 )
 
@@ -51,7 +49,7 @@ func (d *deploymentsGetter) Get(namespace, name string) (runtime.Object, error)
 
 func (d *deploymentsGetter) List(namespace string, query *query.Query) (*api.ListResult, error) {
 	// first retrieves all deployments within given namespace
-	all, err := d.sharedInformers.Apps().V1().Deployments().Lister().Deployments(namespace).List(labels.Everything())
+	all, err := d.sharedInformers.Apps().V1().Deployments().Lister().Deployments(namespace).List(query.Selector())
 	if err != nil {
 		return nil, err
 	}
@@ -77,6 +75,8 @@ func (d *deploymentsGetter) compare(left runtime.Object, right runtime.Object, f
 	}
 
 	switch field {
+	case query.FieldUpdateTime:
+		fallthrough
 	case query.FieldLastUpdateTimestamp:
 		return lastUpdateTime(leftDeployment).After(lastUpdateTime(rightDeployment))
 	default:

pkg/models/resources/v1alpha3/deployment/deployments_test.go

@@ -30,12 +30,7 @@ func TestListDeployments(t *testing.T) {
 				},
 				SortBy:    query.FieldName,
 				Ascending: false,
-				Filters: []query.Filter{
-					{
-						Field: query.FieldName,
-						Value: query.Value("foo2"),
-					},
-				},
+				Filters:   map[query.Field]query.Value{query.FieldName: query.Value("foo2")},
 			},
 			&api.ListResult{
 				Items: []interface{}{

pkg/models/resources/v1alpha3/globalrole/globalroles.go

@@ -0,0 +1,79 @@
+/*
+
+ 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 globalrole
+
+import (
+	"k8s.io/apimachinery/pkg/runtime"
+	"kubesphere.io/kubesphere/pkg/api"
+	iamv1alpha2 "kubesphere.io/kubesphere/pkg/apis/iam/v1alpha2"
+	"kubesphere.io/kubesphere/pkg/apiserver/query"
+	informers "kubesphere.io/kubesphere/pkg/client/informers/externalversions"
+	"kubesphere.io/kubesphere/pkg/models/resources/v1alpha3"
+)
+
+type globalrolesGetter struct {
+	sharedInformers informers.SharedInformerFactory
+}
+
+func New(sharedInformers informers.SharedInformerFactory) v1alpha3.Interface {
+	return &globalrolesGetter{sharedInformers: sharedInformers}
+}
+
+func (d *globalrolesGetter) Get(_, name string) (runtime.Object, error) {
+	return d.sharedInformers.Iam().V1alpha2().GlobalRoles().Lister().Get(name)
+}
+
+func (d *globalrolesGetter) List(_ string, query *query.Query) (*api.ListResult, error) {
+
+	all, err := d.sharedInformers.Iam().V1alpha2().GlobalRoles().Lister().List(query.Selector())
+	if err != nil {
+		return nil, err
+	}
+
+	var result []runtime.Object
+	for _, deploy := range all {
+		result = append(result, deploy)
+	}
+
+	return v1alpha3.DefaultList(result, query, d.compare, d.filter), nil
+}
+
+func (d *globalrolesGetter) compare(left runtime.Object, right runtime.Object, field query.Field) bool {
+
+	leftRole, ok := left.(*iamv1alpha2.GlobalRole)
+	if !ok {
+		return false
+	}
+
+	rightRole, ok := right.(*iamv1alpha2.GlobalRole)
+	if !ok {
+		return false
+	}
+
+	return v1alpha3.DefaultObjectMetaCompare(leftRole.ObjectMeta, rightRole.ObjectMeta, field)
+}
+
+func (d *globalrolesGetter) filter(object runtime.Object, filter query.Filter) bool {
+	role, ok := object.(*iamv1alpha2.GlobalRole)
+
+	if !ok {
+		return false
+	}
+
+	return v1alpha3.DefaultObjectMetaFilter(role.ObjectMeta, filter)
+}

pkg/models/resources/v1alpha3/globalrole/globalroles_test.go

@@ -0,0 +1,94 @@
+package globalrole
+
+import (
+	"github.com/google/go-cmp/cmp"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"kubesphere.io/kubesphere/pkg/api"
+	iamv1alpha2 "kubesphere.io/kubesphere/pkg/apis/iam/v1alpha2"
+	"kubesphere.io/kubesphere/pkg/apiserver/query"
+	"kubesphere.io/kubesphere/pkg/client/clientset/versioned/fake"
+	informers "kubesphere.io/kubesphere/pkg/client/informers/externalversions"
+	"kubesphere.io/kubesphere/pkg/models/resources/v1alpha3"
+	"testing"
+)
+
+func TestListGlobalRoles(t *testing.T) {
+	tests := []struct {
+		description string
+		namespace   string
+		query       *query.Query
+		expected    *api.ListResult
+		expectedErr error
+	}{
+		{
+			"test name filter",
+			"bar",
+			&query.Query{
+				Pagination: &query.Pagination{
+					Limit:  1,
+					Offset: 0,
+				},
+				SortBy:    query.FieldName,
+				Ascending: false,
+				Filters:   map[query.Field]query.Value{query.FieldName: query.Value("foo2")},
+			},
+			&api.ListResult{
+				Items: []interface{}{
+					foo2,
+				},
+				TotalItems: 1,
+			},
+			nil,
+		},
+	}
+
+	getter := prepare()
+
+	for _, test := range tests {
+		t.Run(test.description, func(t *testing.T) {
+
+			got, err := getter.List(test.namespace, test.query)
+
+			if test.expectedErr != nil && err != test.expectedErr {
+				t.Errorf("expected error, got nothing")
+			} else if err != nil {
+				t.Fatal(err)
+			}
+
+			if diff := cmp.Diff(got, test.expected); diff != "" {
+				t.Errorf("%T differ (-got, +want): %s", test.expected, diff)
+			}
+		})
+	}
+}
+
+var (
+	foo1 = &iamv1alpha2.GlobalRole{
+		ObjectMeta: metav1.ObjectMeta{
+			Name: "foo1",
+		},
+	}
+
+	foo2 = &iamv1alpha2.GlobalRole{
+		ObjectMeta: metav1.ObjectMeta{
+			Name: "foo2",
+		},
+	}
+	bar1 = &iamv1alpha2.GlobalRole{
+		ObjectMeta: metav1.ObjectMeta{
+			Name: "bar1",
+		},
+	}
+
+	roles = []interface{}{foo1, foo2, bar1}
+)
+
+func prepare() v1alpha3.Interface {
+	client := fake.NewSimpleClientset()
+	informer := informers.NewSharedInformerFactory(client, 0)
+
+	for _, role := range roles {
+		informer.Iam().V1alpha2().GlobalRoles().Informer().GetIndexer().Add(role)
+	}
+	return New(informer)
+}

pkg/models/resources/v1alpha3/interface.go

@@ -22,13 +22,13 @@ type CompareFunc func(runtime.Object, runtime.Object, query.Field) bool
 
 type FilterFunc func(runtime.Object, query.Filter) bool
 
-func DefaultList(objects []runtime.Object, query *query.Query, compareFunc CompareFunc, filterFunc FilterFunc) *api.ListResult {
+func DefaultList(objects []runtime.Object, q *query.Query, compareFunc CompareFunc, filterFunc FilterFunc) *api.ListResult {
 	// selected matched ones
 	var filtered []runtime.Object
 	for _, object := range objects {
 		selected := true
-		for _, filter := range query.Filters {
-			if !filterFunc(object, filter) {
+		for field, value := range q.Filters {
+			if !filterFunc(object, query.Filter{Field: field, Value: value}) {
 				selected = false
 				break
 			}
@@ -41,14 +41,14 @@ func DefaultList(objects []runtime.Object, query *query.Query, compareFunc Compa
 
 	// sort by sortBy field
 	sort.Slice(filtered, func(i, j int) bool {
-		if !query.Ascending {
-			return compareFunc(filtered[i], filtered[j], query.SortBy)
+		if !q.Ascending {
+			return compareFunc(filtered[i], filtered[j], q.SortBy)
 		}
-		return !compareFunc(filtered[i], filtered[j], query.SortBy)
+		return !compareFunc(filtered[i], filtered[j], q.SortBy)
 	})
 
 	total := len(filtered)
-	start, end := query.Pagination.GetValidPagination(total)
+	start, end := q.Pagination.GetValidPagination(total)
 
 	return &api.ListResult{
 		TotalItems: len(filtered),
@@ -63,6 +63,8 @@ func DefaultObjectMetaCompare(left, right metav1.ObjectMeta, sortBy query.Field)
 	case query.FieldName:
 		return strings.Compare(left.Name, right.Name) > 0
 	//	?sortBy=creationTimestamp
+	case query.FieldCreateTime:
+		fallthrough
 	case query.FieldCreationTimeStamp:
 		// compare by name if creation timestamp is equal
 		if left.CreationTimestamp.Equal(&right.CreationTimestamp) {
@@ -104,29 +106,43 @@ func DefaultObjectMetaFilter(item metav1.ObjectMeta, filter query.Filter) bool {
 		return false
 		// /namespaces?page=1&limit=10&annotation=openpitrix_runtime
 	case query.FieldAnnotation:
-		return containsAnyValue(item.Annotations, string(filter.Value))
+		return labelMatch(item.Annotations, string(filter.Value))
 		// /namespaces?page=1&limit=10&label=kubesphere.io/workspace:system-workspace
 	case query.FieldLabel:
-		return containsAnyValue(item.Labels, string(filter.Value))
+		return labelMatch(item.Labels, string(filter.Value))
 	default:
 		return false
 	}
 }
 
-// Filter format <key:><value>,if the key is defined, the key must match exactly, value match according to strings.Contains.
-func containsAnyValue(keyValues map[string]string, filter string) bool {
-	fields := strings.SplitN(filter, ":", 2)
-	var keyFilter, valueFilter string
+// Filter format (key!?=)?value,if the key is defined, the key must match exactly, value match according to strings.Contains.
+func labelMatch(labels map[string]string, filter string) bool {
+	fields := strings.SplitN(filter, "=", 2)
+	var key, value string
+	var opposite bool
 	if len(fields) == 2 {
-		keyFilter = fields[0]
-		valueFilter = fields[1]
-	} else {
-		valueFilter = fields[0]
-	}
-	for key, value := range keyValues {
-		if (key == keyFilter || keyFilter == "") && strings.Contains(value, valueFilter) {
-			return true
+		key = fields[0]
+		if strings.HasSuffix(key, "!") {
+			key = strings.TrimSuffix(key, "!")
+			opposite = true
 		}
+		value = fields[1]
+	} else {
+		value = fields[0]
+	}
+	for k, v := range labels {
+		if opposite {
+			if (key == "" || k == key) && !strings.Contains(v, value) {
+				return true
+			}
+		} else {
+			if (key == "" || k == key) && strings.Contains(v, value) {
+				return true
+			}
+		}
+	}
+	if opposite && labels[key] == "" {
+		return true
 	}
 	return false
 }

pkg/models/resources/v1alpha3/namespace/namespaces.go

@@ -2,7 +2,6 @@ package namespace
 
 import (
 	v1 "k8s.io/api/core/v1"
-	"k8s.io/apimachinery/pkg/labels"
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/client-go/informers"
 	"kubesphere.io/kubesphere/pkg/api"
@@ -24,7 +23,7 @@ func (n namespaceGetter) Get(_, name string) (runtime.Object, error) {
 }
 
 func (n namespaceGetter) List(_ string, query *query.Query) (*api.ListResult, error) {
-	ns, err := n.informers.Core().V1().Namespaces().Lister().List(labels.Everything())
+	ns, err := n.informers.Core().V1().Namespaces().Lister().List(query.Selector())
 	if err != nil {
 		return nil, err
 	}

pkg/models/resources/v1alpha3/pod/pods.go

@@ -0,0 +1,115 @@
+/*
+
+ 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 pod
+
+import (
+	corev1 "k8s.io/api/core/v1"
+	"k8s.io/apimachinery/pkg/labels"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/client-go/informers"
+	"kubesphere.io/kubesphere/pkg/api"
+	"kubesphere.io/kubesphere/pkg/apiserver/query"
+	"kubesphere.io/kubesphere/pkg/models/resources/v1alpha3"
+)
+
+type podsGetter struct {
+	informer informers.SharedInformerFactory
+}
+
+func New(sharedInformers informers.SharedInformerFactory) v1alpha3.Interface {
+	return &podsGetter{informer: sharedInformers}
+}
+
+func (d *podsGetter) Get(namespace, name string) (runtime.Object, error) {
+	return d.informer.Core().V1().Pods().Lister().Pods(namespace).Get(name)
+}
+
+func (d *podsGetter) List(namespace string, query *query.Query) (*api.ListResult, error) {
+
+	all, err := d.informer.Core().V1().Pods().Lister().Pods(namespace).List(query.Selector())
+	if err != nil {
+		return nil, err
+	}
+
+	var result []runtime.Object
+	for _, app := range all {
+		result = append(result, app)
+	}
+
+	return v1alpha3.DefaultList(result, query, d.compare, d.filter), nil
+}
+
+func (d *podsGetter) compare(left runtime.Object, right runtime.Object, field query.Field) bool {
+
+	leftPod, ok := left.(*corev1.Pod)
+	if !ok {
+		return false
+	}
+
+	rightPod, ok := right.(*corev1.Pod)
+	if !ok {
+		return false
+	}
+
+	return v1alpha3.DefaultObjectMetaCompare(leftPod.ObjectMeta, rightPod.ObjectMeta, field)
+}
+
+func (d *podsGetter) filter(object runtime.Object, filter query.Filter) bool {
+	pod, ok := object.(*corev1.Pod)
+
+	if !ok {
+		return false
+	}
+	switch filter.Field {
+	case "nodeName":
+		if pod.Spec.NodeName != string(filter.Value) {
+			return false
+		}
+	case "pvcName":
+		if !d.podBindPVC(pod, string(filter.Value)) {
+			return false
+		}
+	case "serviceName":
+		if !d.podBelongToService(pod, string(filter.Value)) {
+			return false
+		}
+	}
+	return v1alpha3.DefaultObjectMetaFilter(pod.ObjectMeta, filter)
+}
+
+func (s *podsGetter) podBindPVC(item *corev1.Pod, pvcName string) bool {
+	for _, v := range item.Spec.Volumes {
+		if v.VolumeSource.PersistentVolumeClaim != nil &&
+			v.VolumeSource.PersistentVolumeClaim.ClaimName == pvcName {
+			return true
+		}
+	}
+	return false
+}
+
+func (s *podsGetter) podBelongToService(item *corev1.Pod, serviceName string) bool {
+	service, err := s.informer.Core().V1().Services().Lister().Services(item.Namespace).Get(serviceName)
+	if err != nil {
+		return false
+	}
+	selector := labels.Set(service.Spec.Selector).AsSelectorPreValidated()
+	if selector.Empty() || !selector.Matches(labels.Set(item.Labels)) {
+		return false
+	}
+	return true
+}

pkg/models/resources/v1alpha3/pod/pods_test.go

@@ -0,0 +1,91 @@
+package pod
+
+import (
+	"github.com/google/go-cmp/cmp"
+	corev1 "k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/client-go/informers"
+	"k8s.io/client-go/kubernetes/fake"
+	"kubesphere.io/kubesphere/pkg/api"
+	"kubesphere.io/kubesphere/pkg/apiserver/query"
+	"kubesphere.io/kubesphere/pkg/models/resources/v1alpha3"
+	"testing"
+)
+
+func TestListPods(t *testing.T) {
+	tests := []struct {
+		description string
+		namespace   string
+		query       *query.Query
+		expected    *api.ListResult
+		expectedErr error
+	}{
+		{
+			"test name filter",
+			"default",
+			&query.Query{
+				Pagination: &query.Pagination{
+					Limit:  10,
+					Offset: 0,
+				},
+				SortBy:    query.FieldName,
+				Ascending: false,
+				Filters:   map[query.Field]query.Value{query.FieldNamespace: query.Value("default")},
+			},
+			&api.ListResult{
+				Items:      []interface{}{foo3, foo2, foo1},
+				TotalItems: len(pods),
+			},
+			nil,
+		},
+	}
+
+	getter := prepare()
+
+	for _, test := range tests {
+		got, err := getter.List(test.namespace, test.query)
+		if test.expectedErr != nil && err != test.expectedErr {
+			t.Errorf("expected error, got nothing")
+		} else if err != nil {
+			t.Fatal(err)
+		}
+
+		if diff := cmp.Diff(got, test.expected); diff != "" {
+			t.Errorf("%T differ (-got, +want): %s", test.expected, diff)
+		}
+	}
+}
+
+var (
+	foo1 = &corev1.Pod{
+		ObjectMeta: metav1.ObjectMeta{
+			Name:      "foo1",
+			Namespace: "default",
+		},
+	}
+	foo2 = &corev1.Pod{
+		ObjectMeta: metav1.ObjectMeta{
+			Name:      "foo2",
+			Namespace: "default",
+		},
+	}
+	foo3 = &corev1.Pod{
+		ObjectMeta: metav1.ObjectMeta{
+			Name:      "foo3",
+			Namespace: "default",
+		},
+	}
+	pods = []interface{}{foo1, foo2, foo3}
+)
+
+func prepare() v1alpha3.Interface {
+
+	client := fake.NewSimpleClientset()
+	informer := informers.NewSharedInformerFactory(client, 0)
+
+	for _, pod := range pods {
+		informer.Core().V1().Pods().Informer().GetIndexer().Add(pod)
+	}
+
+	return New(informer)
+}

pkg/models/resources/v1alpha3/resource/resource.go

@@ -1,15 +1,45 @@
+/*
+ *
+ * Copyright 2020 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 resource
 
 import (
 	"errors"
+	rbacv1 "k8s.io/api/rbac/v1"
+	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apimachinery/pkg/runtime/schema"
 	"kubesphere.io/kubesphere/pkg/api"
+	iamv1alpha2 "kubesphere.io/kubesphere/pkg/apis/iam/v1alpha2"
+	tenantv1alpha1 "kubesphere.io/kubesphere/pkg/apis/tenant/v1alpha1"
 	"kubesphere.io/kubesphere/pkg/apiserver/query"
 	"kubesphere.io/kubesphere/pkg/informers"
 	"kubesphere.io/kubesphere/pkg/models/resources/v1alpha3"
 	"kubesphere.io/kubesphere/pkg/models/resources/v1alpha3/application"
+	"kubesphere.io/kubesphere/pkg/models/resources/v1alpha3/clusterrole"
+	"kubesphere.io/kubesphere/pkg/models/resources/v1alpha3/configmap"
 	"kubesphere.io/kubesphere/pkg/models/resources/v1alpha3/deployment"
+	"kubesphere.io/kubesphere/pkg/models/resources/v1alpha3/globalrole"
 	"kubesphere.io/kubesphere/pkg/models/resources/v1alpha3/namespace"
+	"kubesphere.io/kubesphere/pkg/models/resources/v1alpha3/pod"
+	"kubesphere.io/kubesphere/pkg/models/resources/v1alpha3/role"
+	"kubesphere.io/kubesphere/pkg/models/resources/v1alpha3/user"
+	"kubesphere.io/kubesphere/pkg/models/resources/v1alpha3/workspace"
+	"kubesphere.io/kubesphere/pkg/models/resources/v1alpha3/workspacerole"
 )
 
 var ErrResourceNotSupported = errors.New("resource is not supported")
@@ -23,7 +53,15 @@ func NewResourceGetter(factory informers.InformerFactory) *ResourceGetter {
 
 	getters[schema.GroupVersionResource{Group: "apps", Version: "v1", Resource: "deployments"}] = deployment.New(factory.KubernetesSharedInformerFactory())
 	getters[schema.GroupVersionResource{Group: "", Version: "v1", Resource: "namespaces"}] = namespace.New(factory.KubernetesSharedInformerFactory())
+	getters[schema.GroupVersionResource{Group: "", Version: "v1", Resource: "configmaps"}] = configmap.New(factory.KubernetesSharedInformerFactory())
+	getters[schema.GroupVersionResource{Group: "", Version: "v1", Resource: "pods"}] = pod.New(factory.KubernetesSharedInformerFactory())
 	getters[schema.GroupVersionResource{Group: "app.k8s.io", Version: "v1beta1", Resource: "applications"}] = application.New(factory.ApplicationSharedInformerFactory())
+	getters[tenantv1alpha1.SchemeGroupVersion.WithResource(tenantv1alpha1.ResourcePluralWorkspace)] = workspace.New(factory.KubeSphereSharedInformerFactory())
+	getters[iamv1alpha2.SchemeGroupVersion.WithResource(iamv1alpha2.ResourcesPluralGlobalRole)] = globalrole.New(factory.KubeSphereSharedInformerFactory())
+	getters[iamv1alpha2.SchemeGroupVersion.WithResource(iamv1alpha2.ResourcesPluralWorkspaceRole)] = workspacerole.New(factory.KubeSphereSharedInformerFactory())
+	getters[iamv1alpha2.SchemeGroupVersion.WithResource(iamv1alpha2.ResourcesPluralUser)] = user.New(factory.KubeSphereSharedInformerFactory())
+	getters[rbacv1.SchemeGroupVersion.WithResource("roles")] = role.New(factory.KubernetesSharedInformerFactory())
+	getters[rbacv1.SchemeGroupVersion.WithResource("clusterroles")] = clusterrole.New(factory.KubernetesSharedInformerFactory())
 
 	return &ResourceGetter{
 		getters: getters,
@@ -38,11 +76,10 @@ func (r *ResourceGetter) tryResource(resource string) v1alpha3.Interface {
 			return v
 		}
 	}
-
 	return nil
 }
 
-func (r *ResourceGetter) Get(resource, namespace, name string) (interface{}, error) {
+func (r *ResourceGetter) Get(resource, namespace, name string) (runtime.Object, error) {
 	getter := r.tryResource(resource)
 	if getter == nil {
 		return nil, ErrResourceNotSupported

pkg/models/resources/v1alpha3/resource/resource_test.go

@@ -55,7 +55,7 @@ func TestResourceGetter(t *testing.T) {
 				},
 				SortBy:    query.FieldName,
 				Ascending: false,
-				Filters:   []query.Filter{},
+				Filters:   map[query.Field]query.Value{},
 			},
 			ExpectError: nil,
 			ExpectResponse: &api.ListResult{

pkg/models/resources/v1alpha3/role/roles.go

@@ -0,0 +1,79 @@
+/*
+
+ 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 role
+
+import (
+	rbacv1 "k8s.io/api/rbac/v1"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/client-go/informers"
+	"kubesphere.io/kubesphere/pkg/api"
+	"kubesphere.io/kubesphere/pkg/apiserver/query"
+	"kubesphere.io/kubesphere/pkg/models/resources/v1alpha3"
+)
+
+type rolesGetter struct {
+	sharedInformers informers.SharedInformerFactory
+}
+
+func New(sharedInformers informers.SharedInformerFactory) v1alpha3.Interface {
+	return &rolesGetter{sharedInformers: sharedInformers}
+}
+
+func (d *rolesGetter) Get(namespace, name string) (runtime.Object, error) {
+	return d.sharedInformers.Rbac().V1().Roles().Lister().Roles(namespace).Get(name)
+}
+
+func (d *rolesGetter) List(namespace string, query *query.Query) (*api.ListResult, error) {
+	all, err := d.sharedInformers.Rbac().V1().Roles().Lister().Roles(namespace).List(query.Selector())
+
+	if err != nil {
+		return nil, err
+	}
+
+	var result []runtime.Object
+	for _, deploy := range all {
+		result = append(result, deploy)
+	}
+
+	return v1alpha3.DefaultList(result, query, d.compare, d.filter), nil
+}
+
+func (d *rolesGetter) compare(left runtime.Object, right runtime.Object, field query.Field) bool {
+
+	leftRole, ok := left.(*rbacv1.Role)
+	if !ok {
+		return false
+	}
+
+	rightRole, ok := right.(*rbacv1.Role)
+	if !ok {
+		return false
+	}
+
+	return v1alpha3.DefaultObjectMetaCompare(leftRole.ObjectMeta, rightRole.ObjectMeta, field)
+}
+
+func (d *rolesGetter) filter(object runtime.Object, filter query.Filter) bool {
+	role, ok := object.(*rbacv1.Role)
+
+	if !ok {
+		return false
+	}
+
+	return v1alpha3.DefaultObjectMetaFilter(role.ObjectMeta, filter)
+}

pkg/models/resources/v1alpha3/role/roles_test.go

@@ -0,0 +1,97 @@
+package role
+
+import (
+	"github.com/google/go-cmp/cmp"
+	rbacv1 "k8s.io/api/rbac/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/client-go/informers"
+	"k8s.io/client-go/kubernetes/fake"
+	"kubesphere.io/kubesphere/pkg/api"
+	"kubesphere.io/kubesphere/pkg/apiserver/query"
+	"kubesphere.io/kubesphere/pkg/models/resources/v1alpha3"
+	"testing"
+)
+
+func TestListRoles(t *testing.T) {
+	tests := []struct {
+		description string
+		namespace   string
+		query       *query.Query
+		expected    *api.ListResult
+		expectedErr error
+	}{
+		{
+			"test name filter",
+			"bar",
+			&query.Query{
+				Pagination: &query.Pagination{
+					Limit:  1,
+					Offset: 0,
+				},
+				SortBy:    query.FieldName,
+				Ascending: false,
+				Filters:   map[query.Field]query.Value{query.FieldName: query.Value("foo2")},
+			},
+			&api.ListResult{
+				Items: []interface{}{
+					foo2,
+				},
+				TotalItems: 1,
+			},
+			nil,
+		},
+	}
+
+	getter := prepare()
+
+	for _, test := range tests {
+		t.Run(test.description, func(t *testing.T) {
+
+			got, err := getter.List(test.namespace, test.query)
+
+			if test.expectedErr != nil && err != test.expectedErr {
+				t.Errorf("expected error, got nothing")
+			} else if err != nil {
+				t.Fatal(err)
+			}
+
+			if diff := cmp.Diff(got, test.expected); diff != "" {
+				t.Errorf("%T differ (-got, +want): %s", test.expected, diff)
+			}
+		})
+	}
+}
+
+var (
+	foo1 = &rbacv1.Role{
+		ObjectMeta: metav1.ObjectMeta{
+			Name:      "foo1",
+			Namespace: "bar",
+		},
+	}
+
+	foo2 = &rbacv1.Role{
+		ObjectMeta: metav1.ObjectMeta{
+			Name:      "foo2",
+			Namespace: "bar",
+		},
+	}
+	bar1 = &rbacv1.Role{
+		ObjectMeta: metav1.ObjectMeta{
+			Name:      "bar1",
+			Namespace: "bar",
+		},
+	}
+
+	roles = []interface{}{foo1, foo2, bar1}
+)
+
+func prepare() v1alpha3.Interface {
+	client := fake.NewSimpleClientset()
+	informer := informers.NewSharedInformerFactory(client, 0)
+
+	for _, role := range roles {
+		informer.Rbac().V1().Roles().Informer().GetIndexer().Add(role)
+	}
+	return New(informer)
+}

pkg/models/resources/v1alpha3/user/users.go

@@ -0,0 +1,79 @@
+/*
+
+ 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 user
+
+import (
+	"k8s.io/apimachinery/pkg/runtime"
+	"kubesphere.io/kubesphere/pkg/api"
+	iamv1alpha2 "kubesphere.io/kubesphere/pkg/apis/iam/v1alpha2"
+	"kubesphere.io/kubesphere/pkg/apiserver/query"
+	informers "kubesphere.io/kubesphere/pkg/client/informers/externalversions"
+	"kubesphere.io/kubesphere/pkg/models/resources/v1alpha3"
+)
+
+type usersGetter struct {
+	sharedInformers informers.SharedInformerFactory
+}
+
+func New(sharedInformers informers.SharedInformerFactory) v1alpha3.Interface {
+	return &usersGetter{sharedInformers: sharedInformers}
+}
+
+func (d *usersGetter) Get(_, name string) (runtime.Object, error) {
+	return d.sharedInformers.Iam().V1alpha2().Users().Lister().Get(name)
+}
+
+func (d *usersGetter) List(_ string, query *query.Query) (*api.ListResult, error) {
+
+	all, err := d.sharedInformers.Iam().V1alpha2().Users().Lister().List(query.Selector())
+	if err != nil {
+		return nil, err
+	}
+
+	var result []runtime.Object
+	for _, deploy := range all {
+		result = append(result, deploy)
+	}
+
+	return v1alpha3.DefaultList(result, query, d.compare, d.filter), nil
+}
+
+func (d *usersGetter) compare(left runtime.Object, right runtime.Object, field query.Field) bool {
+
+	leftRole, ok := left.(*iamv1alpha2.User)
+	if !ok {
+		return false
+	}
+
+	rightRole, ok := right.(*iamv1alpha2.User)
+	if !ok {
+		return false
+	}
+
+	return v1alpha3.DefaultObjectMetaCompare(leftRole.ObjectMeta, rightRole.ObjectMeta, field)
+}
+
+func (d *usersGetter) filter(object runtime.Object, filter query.Filter) bool {
+	role, ok := object.(*iamv1alpha2.User)
+
+	if !ok {
+		return false
+	}
+
+	return v1alpha3.DefaultObjectMetaFilter(role.ObjectMeta, filter)
+}

pkg/models/resources/v1alpha3/user/users_test.go

@@ -0,0 +1,94 @@
+package user
+
+import (
+	"github.com/google/go-cmp/cmp"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"kubesphere.io/kubesphere/pkg/api"
+	iamv1alpha2 "kubesphere.io/kubesphere/pkg/apis/iam/v1alpha2"
+	"kubesphere.io/kubesphere/pkg/apiserver/query"
+	"kubesphere.io/kubesphere/pkg/client/clientset/versioned/fake"
+	informers "kubesphere.io/kubesphere/pkg/client/informers/externalversions"
+	"kubesphere.io/kubesphere/pkg/models/resources/v1alpha3"
+	"testing"
+)
+
+func TestListUsers(t *testing.T) {
+	tests := []struct {
+		description string
+		namespace   string
+		query       *query.Query
+		expected    *api.ListResult
+		expectedErr error
+	}{
+		{
+			"test name filter",
+			"bar",
+			&query.Query{
+				Pagination: &query.Pagination{
+					Limit:  1,
+					Offset: 0,
+				},
+				SortBy:    query.FieldName,
+				Ascending: false,
+				Filters:   map[query.Field]query.Value{query.FieldName: query.Value("foo2")},
+			},
+			&api.ListResult{
+				Items: []interface{}{
+					foo2,
+				},
+				TotalItems: 1,
+			},
+			nil,
+		},
+	}
+
+	getter := prepare()
+
+	for _, test := range tests {
+		t.Run(test.description, func(t *testing.T) {
+
+			got, err := getter.List(test.namespace, test.query)
+
+			if test.expectedErr != nil && err != test.expectedErr {
+				t.Errorf("expected error, got nothing")
+			} else if err != nil {
+				t.Fatal(err)
+			}
+
+			if diff := cmp.Diff(got, test.expected); diff != "" {
+				t.Errorf("%T differ (-got, +want): %s", test.expected, diff)
+			}
+		})
+	}
+}
+
+var (
+	foo1 = &iamv1alpha2.User{
+		ObjectMeta: metav1.ObjectMeta{
+			Name: "foo1",
+		},
+	}
+
+	foo2 = &iamv1alpha2.User{
+		ObjectMeta: metav1.ObjectMeta{
+			Name: "foo2",
+		},
+	}
+	bar1 = &iamv1alpha2.User{
+		ObjectMeta: metav1.ObjectMeta{
+			Name: "bar1",
+		},
+	}
+
+	users = []interface{}{foo1, foo2, bar1}
+)
+
+func prepare() v1alpha3.Interface {
+	client := fake.NewSimpleClientset()
+	informer := informers.NewSharedInformerFactory(client, 0)
+
+	for _, user := range users {
+		informer.Iam().V1alpha2().Users().Informer().GetIndexer().Add(user)
+	}
+	return New(informer)
+}

pkg/models/resources/v1alpha3/workspace/workspaces.go

@@ -0,0 +1,79 @@
+/*
+
+ 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 workspace
+
+import (
+	"k8s.io/apimachinery/pkg/runtime"
+	"kubesphere.io/kubesphere/pkg/api"
+	tenantv1alpha1 "kubesphere.io/kubesphere/pkg/apis/tenant/v1alpha1"
+	"kubesphere.io/kubesphere/pkg/apiserver/query"
+	informers "kubesphere.io/kubesphere/pkg/client/informers/externalversions"
+	"kubesphere.io/kubesphere/pkg/models/resources/v1alpha3"
+)
+
+type workspaceGetter struct {
+	sharedInformers informers.SharedInformerFactory
+}
+
+func New(sharedInformers informers.SharedInformerFactory) v1alpha3.Interface {
+	return &workspaceGetter{sharedInformers: sharedInformers}
+}
+
+func (d *workspaceGetter) Get(_, name string) (runtime.Object, error) {
+	return d.sharedInformers.Tenant().V1alpha1().Workspaces().Lister().Get(name)
+}
+
+func (d *workspaceGetter) List(_ string, query *query.Query) (*api.ListResult, error) {
+
+	all, err := d.sharedInformers.Tenant().V1alpha1().Workspaces().Lister().List(query.Selector())
+	if err != nil {
+		return nil, err
+	}
+
+	var result []runtime.Object
+	for _, deploy := range all {
+		result = append(result, deploy)
+	}
+
+	return v1alpha3.DefaultList(result, query, d.compare, d.filter), nil
+}
+
+func (d *workspaceGetter) compare(left runtime.Object, right runtime.Object, field query.Field) bool {
+
+	leftRole, ok := left.(*tenantv1alpha1.Workspace)
+	if !ok {
+		return false
+	}
+
+	rightRole, ok := right.(*tenantv1alpha1.Workspace)
+	if !ok {
+		return false
+	}
+
+	return v1alpha3.DefaultObjectMetaCompare(leftRole.ObjectMeta, rightRole.ObjectMeta, field)
+}
+
+func (d *workspaceGetter) filter(object runtime.Object, filter query.Filter) bool {
+	role, ok := object.(*tenantv1alpha1.Workspace)
+
+	if !ok {
+		return false
+	}
+
+	return v1alpha3.DefaultObjectMetaFilter(role.ObjectMeta, filter)
+}

pkg/models/resources/v1alpha3/workspace/workspaces_test.go

@@ -0,0 +1,94 @@
+package workspace
+
+import (
+	"github.com/google/go-cmp/cmp"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"kubesphere.io/kubesphere/pkg/api"
+	tenantv1alpha1 "kubesphere.io/kubesphere/pkg/apis/tenant/v1alpha1"
+	"kubesphere.io/kubesphere/pkg/apiserver/query"
+	"kubesphere.io/kubesphere/pkg/client/clientset/versioned/fake"
+	informers "kubesphere.io/kubesphere/pkg/client/informers/externalversions"
+	"kubesphere.io/kubesphere/pkg/models/resources/v1alpha3"
+	"testing"
+)
+
+func TestListWorkspaces(t *testing.T) {
+	tests := []struct {
+		description string
+		namespace   string
+		query       *query.Query
+		expected    *api.ListResult
+		expectedErr error
+	}{
+		{
+			"test name filter",
+			"bar",
+			&query.Query{
+				Pagination: &query.Pagination{
+					Limit:  1,
+					Offset: 0,
+				},
+				SortBy:    query.FieldName,
+				Ascending: false,
+				Filters:   map[query.Field]query.Value{query.FieldName: query.Value("foo2")},
+			},
+			&api.ListResult{
+				Items: []interface{}{
+					foo2,
+				},
+				TotalItems: 1,
+			},
+			nil,
+		},
+	}
+
+	getter := prepare()
+
+	for _, test := range tests {
+		t.Run(test.description, func(t *testing.T) {
+
+			got, err := getter.List(test.namespace, test.query)
+
+			if test.expectedErr != nil && err != test.expectedErr {
+				t.Errorf("expected error, got nothing")
+			} else if err != nil {
+				t.Fatal(err)
+			}
+
+			if diff := cmp.Diff(got, test.expected); diff != "" {
+				t.Errorf("%T differ (-got, +want): %s", test.expected, diff)
+			}
+		})
+	}
+}
+
+var (
+	foo1 = &tenantv1alpha1.Workspace{
+		ObjectMeta: metav1.ObjectMeta{
+			Name: "foo1",
+		},
+	}
+
+	foo2 = &tenantv1alpha1.Workspace{
+		ObjectMeta: metav1.ObjectMeta{
+			Name: "foo2",
+		},
+	}
+	bar1 = &tenantv1alpha1.Workspace{
+		ObjectMeta: metav1.ObjectMeta{
+			Name: "bar1",
+		},
+	}
+
+	workspaces = []interface{}{foo1, foo2, bar1}
+)
+
+func prepare() v1alpha3.Interface {
+	client := fake.NewSimpleClientset()
+	informer := informers.NewSharedInformerFactory(client, 0)
+
+	for _, workspace := range workspaces {
+		informer.Tenant().V1alpha1().Workspaces().Informer().GetIndexer().Add(workspace)
+	}
+	return New(informer)
+}

pkg/models/resources/v1alpha3/workspacerole/workspaceroles.go

@@ -0,0 +1,79 @@
+/*
+
+ 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 workspacerole
+
+import (
+	"k8s.io/apimachinery/pkg/runtime"
+	"kubesphere.io/kubesphere/pkg/api"
+	iamv1alpha2 "kubesphere.io/kubesphere/pkg/apis/iam/v1alpha2"
+	"kubesphere.io/kubesphere/pkg/apiserver/query"
+	informers "kubesphere.io/kubesphere/pkg/client/informers/externalversions"
+	"kubesphere.io/kubesphere/pkg/models/resources/v1alpha3"
+)
+
+type workspacerolesGetter struct {
+	sharedInformers informers.SharedInformerFactory
+}
+
+func New(sharedInformers informers.SharedInformerFactory) v1alpha3.Interface {
+	return &workspacerolesGetter{sharedInformers: sharedInformers}
+}
+
+func (d *workspacerolesGetter) Get(_, name string) (runtime.Object, error) {
+	return d.sharedInformers.Iam().V1alpha2().WorkspaceRoles().Lister().Get(name)
+}
+
+func (d *workspacerolesGetter) List(_ string, query *query.Query) (*api.ListResult, error) {
+
+	all, err := d.sharedInformers.Iam().V1alpha2().WorkspaceRoles().Lister().List(query.Selector())
+	if err != nil {
+		return nil, err
+	}
+
+	var result []runtime.Object
+	for _, deploy := range all {
+		result = append(result, deploy)
+	}
+
+	return v1alpha3.DefaultList(result, query, d.compare, d.filter), nil
+}
+
+func (d *workspacerolesGetter) compare(left runtime.Object, right runtime.Object, field query.Field) bool {
+
+	leftRole, ok := left.(*iamv1alpha2.WorkspaceRole)
+	if !ok {
+		return false
+	}
+
+	rightRole, ok := right.(*iamv1alpha2.WorkspaceRole)
+	if !ok {
+		return false
+	}
+
+	return v1alpha3.DefaultObjectMetaCompare(leftRole.ObjectMeta, rightRole.ObjectMeta, field)
+}
+
+func (d *workspacerolesGetter) filter(object runtime.Object, filter query.Filter) bool {
+	role, ok := object.(*iamv1alpha2.WorkspaceRole)
+
+	if !ok {
+		return false
+	}
+
+	return v1alpha3.DefaultObjectMetaFilter(role.ObjectMeta, filter)
+}

pkg/models/resources/v1alpha3/workspacerole/workspaceroles_test.go

@@ -0,0 +1,94 @@
+package workspacerole
+
+import (
+	"github.com/google/go-cmp/cmp"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"kubesphere.io/kubesphere/pkg/api"
+	iamv1alpha2 "kubesphere.io/kubesphere/pkg/apis/iam/v1alpha2"
+	"kubesphere.io/kubesphere/pkg/apiserver/query"
+	"kubesphere.io/kubesphere/pkg/client/clientset/versioned/fake"
+	informers "kubesphere.io/kubesphere/pkg/client/informers/externalversions"
+	"kubesphere.io/kubesphere/pkg/models/resources/v1alpha3"
+	"testing"
+)
+
+func TestListWorkspaceRoles(t *testing.T) {
+	tests := []struct {
+		description string
+		namespace   string
+		query       *query.Query
+		expected    *api.ListResult
+		expectedErr error
+	}{
+		{
+			"test name filter",
+			"bar",
+			&query.Query{
+				Pagination: &query.Pagination{
+					Limit:  1,
+					Offset: 0,
+				},
+				SortBy:    query.FieldName,
+				Ascending: false,
+				Filters:   map[query.Field]query.Value{query.FieldName: query.Value("foo2")},
+			},
+			&api.ListResult{
+				Items: []interface{}{
+					foo2,
+				},
+				TotalItems: 1,
+			},
+			nil,
+		},
+	}
+
+	getter := prepare()
+
+	for _, test := range tests {
+		t.Run(test.description, func(t *testing.T) {
+
+			got, err := getter.List(test.namespace, test.query)
+
+			if test.expectedErr != nil && err != test.expectedErr {
+				t.Errorf("expected error, got nothing")
+			} else if err != nil {
+				t.Fatal(err)
+			}
+
+			if diff := cmp.Diff(got, test.expected); diff != "" {
+				t.Errorf("%T differ (-got, +want): %s", test.expected, diff)
+			}
+		})
+	}
+}
+
+var (
+	foo1 = &iamv1alpha2.WorkspaceRole{
+		ObjectMeta: metav1.ObjectMeta{
+			Name: "foo1",
+		},
+	}
+
+	foo2 = &iamv1alpha2.WorkspaceRole{
+		ObjectMeta: metav1.ObjectMeta{
+			Name: "foo2",
+		},
+	}
+	bar1 = &iamv1alpha2.WorkspaceRole{
+		ObjectMeta: metav1.ObjectMeta{
+			Name: "bar1",
+		},
+	}
+
+	roles = []interface{}{foo1, foo2, bar1}
+)
+
+func prepare() v1alpha3.Interface {
+	client := fake.NewSimpleClientset()
+	informer := informers.NewSharedInformerFactory(client, 0)
+
+	for _, role := range roles {
+		informer.Iam().V1alpha2().WorkspaceRoles().Informer().GetIndexer().Add(role)
+	}
+	return New(informer)
+}