admin/kubesphere
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

refactor code structure (#1738)

Browse Source
This commit is contained in:
zryfish
2020-01-04 12:44:54 +08:00
committed by GitHub
parent eceadec69c
commit c40d1542a2
50 changed files with 695 additions and 456 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
pkg/models/resources/v1alpha3/deployment/deployments.go
View File

@@ -18,7 +18,9 @@
package deployment
import (
"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"
"strings"
@@ -46,26 +48,26 @@ func New(sharedInformers informers.SharedInformerFactory) v1alpha3.Interface {
return &deploymentsGetter{sharedInformers: sharedInformers}
}
func (d *deploymentsGetter) Get(namespace, name string) (interface{}, error) {
func (d *deploymentsGetter) Get(namespace, name string) (runtime.Object, error) {
return d.sharedInformers.Apps().V1().Deployments().Lister().Deployments(namespace).Get(name)
}
func (d *deploymentsGetter) List(namespace string) ([]interface{}, 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())
if err != nil {
return nil, err
}
var result []interface{}
var result []runtime.Object
for _, deploy := range all {
result = append(result, deploy)
}
return result, nil
return v1alpha3.DefaultList(result, query, d.compare, d.filter), nil
}
func (d *deploymentsGetter) Compare(left interface{}, right interface{}, field query.Field) bool {
func (d *deploymentsGetter) compare(left runtime.Object, right runtime.Object, field query.Field) bool {
leftDeployment, ok := left.(*v1.Deployment)
if !ok {
@@ -89,7 +91,7 @@ func (d *deploymentsGetter) Compare(left interface{}, right interface{}, field q
}
}
func (d *deploymentsGetter) Filter(object interface{}, filter query.Filter) bool {
func (d *deploymentsGetter) filter(object runtime.Object, filter query.Filter) bool {
deployment, ok := object.(*v1.Deployment)
if !ok {
return false

1
pkg/models/resources/v1alpha3/deployment/deployments_test.go
View File

@@ -125,7 +125,6 @@ func TestListDeployments(t *testing.T) {
t.Run(test.description, func(t *testing.T) {
objs := deploymentsToRuntimeObjects(test.deployments...)
client := fake.NewSimpleClientset(objs...)
//client := fake.NewSimpleClientset()
informer := informers.NewSharedInformerFactory(client, 0)

64
pkg/models/resources/v1alpha3/interface.go
View File

@@ -1,19 +1,67 @@
package v1alpha3
import (
"k8s.io/apimachinery/pkg/runtime"
"kubesphere.io/kubesphere/pkg/api"
"kubesphere.io/kubesphere/pkg/apiserver/query"
"sort"
)
type Interface interface {
// Get retrieves a single object by its namespace and name
Get(namespace, name string) (interface{}, error)
Get(namespace, name string) (runtime.Object, error)
// List retrieves a collection of objects matches given query
List(namespace string) ([]interface{}, error)
//
Filter(item interface{}, filter query.Filter) bool
//
Compare(left interface{}, right interface{}, field query.Field) bool
List(namespace string, query *query.Query) (*api.ListResult, error)
}
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 {
// selected matched ones
var filtered []runtime.Object
for _, object := range objects {
selected := true
for _, filter := range query.Filters {
if !filterFunc(object, filter) {
selected = false
break
}
}
if selected {
filtered = append(filtered, object)
}
}
start, end := query.Pagination.GetPaginationSettings(len(filtered))
if !query.Pagination.IsPageAvailable(len(filtered), start) {
return &api.ListResult{
Items: nil,
TotalItems: 0,
}
}
// sort by sortBy field
sort.Slice(filtered, func(i, j int) bool {
if !query.Ascending {
return !compareFunc(filtered[i], filtered[j], query.SortBy)
}
return compareFunc(filtered[i], filtered[j], query.SortBy)
})
return &api.ListResult{
Items: objectsToInterfaces(filtered[start:end]),
TotalItems: len(filtered),
}
}
func objectsToInterfaces(objs []runtime.Object) []interface{} {
var res []interface{}
for _, obj := range objs {
res = append(res, obj)
}
return res
}

75
pkg/models/resources/v1alpha3/namespace/namespaces.go Normal file
View File

@@ -0,0 +1,75 @@
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"
"kubesphere.io/kubesphere/pkg/apiserver/query"
"kubesphere.io/kubesphere/pkg/models/resources/v1alpha3"
"strings"
)
type namespaceGetter struct {
informers informers.SharedInformerFactory
}
func NewNamespaceGetter(informers informers.SharedInformerFactory) v1alpha3.Interface {
return &namespaceGetter{informers:informers}
}
func (n namespaceGetter) Get(_, name string) (runtime.Object, error) {
return n.informers.Core().V1().Namespaces().Lister().Get(name)
}
func (n namespaceGetter) List(_ string, query *query.Query) (*api.ListResult, error) {
ns, err := n.informers.Core().V1().Namespaces().Lister().List(labels.Everything())
if err != nil {
return nil, err
}
var result []runtime.Object
for _, item := range ns {
result = append(result, item)
}
return v1alpha3.DefaultList(result, query, n.compare, n.filter), nil
}
func (n namespaceGetter) filter(item runtime.Object, filter query.Filter) bool {
namespace, ok := item.(*v1.Namespace)
if !ok {
return false
}
switch filter.Field {
case query.FieldName:
return query.ComparableString(namespace.Name).Contains(filter.Value)
case query.FieldStatus:
return query.ComparableString(namespace.Status.Phase).Compare(filter.Value) == 0
default:
return false
}
}
func (n namespaceGetter) compare(left runtime.Object, right runtime.Object, field query.Field) bool {
leftNs, ok := left.(*v1.Namespace)
if !ok {
return false
}
rightNs, ok := right.(*v1.Namespace)
if !ok {
return true
}
switch field {
case query.FieldName:
return strings.Compare(leftNs.Name, rightNs.Name) > 0
case query.FieldCreationTimeStamp:
return leftNs.CreationTimestamp.After(rightNs.CreationTimestamp.Time)
default:
return false
}
}

1
pkg/models/resources/v1alpha3/namespace/namespaces_test.go Normal file
View File

@@ -0,0 +1 @@
package namespace

48
pkg/models/resources/v1alpha3/resource/resource.go
View File

@@ -3,12 +3,11 @@ package resource
import (
"errors"
"k8s.io/apimachinery/pkg/runtime/schema"
"k8s.io/client-go/informers"
"kubesphere.io/kubesphere/pkg/api"
"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/deployment"
"sort"
)
var ErrResourceNotSupported = errors.New("resource is not supported")
@@ -17,10 +16,10 @@ type NamespacedResourceGetter struct {
getters map[schema.GroupVersionResource]v1alpha3.Interface
}
func New(informers informers.SharedInformerFactory) *NamespacedResourceGetter {
func New(factory informers.InformerFactory) *NamespacedResourceGetter {
getters := make(map[schema.GroupVersionResource]v1alpha3.Interface)
getters[schema.GroupVersionResource{Group: "apps", Version: "v1", Resource: "deployments"}] = deployment.New(informers)
getters[schema.GroupVersionResource{Group: "apps", Version: "v1", Resource: "deployments"}] = deployment.New(factory.KubernetesSharedInformerFactory())
return &NamespacedResourceGetter{
getters: getters,
@@ -54,45 +53,6 @@ func (r *NamespacedResourceGetter) List(resource, namespace string, query *query
return nil, ErrResourceNotSupported
}
all, err := getter.List(namespace)
if err != nil {
return nil, err
}
return getter.List(namespace, query)
// selected matched ones
var filtered []interface{}
for _, deploy := range all {
for _, filter := range query.Filters {
if getter.Filter(deploy, filter) {
filtered = append(filtered, deploy)
}
}
}
// sort
sort.Slice(filtered, func(i, j int) bool {
if !query.Ascending {
return !getter.Compare(filtered[i], filtered[j], query.SortBy)
}
return getter.Compare(filtered[i], filtered[j], query.SortBy)
})
start, end := query.Pagination.GetPaginationSettings(len(filtered))
if query.Pagination.IsPageAvailable(len(filtered), start) {
var result []interface{}
for i := start; i < end; i++ {
result = append(result, filtered[i])
}
return &api.ListResult{
Items: result,
TotalItems: len(filtered),
}, nil
}
return &api.ListResult{
Items: nil,
TotalItems: len(filtered),
}, nil
}