github.com/oam-dev/kubevela@v1.9.11/references/cli/top/model/managed_resource.go (about)

     1  /*
     2  Copyright 2022 The KubeVela Authors.
     3  
     4  Licensed under the Apache License, Version 2.0 (the "License");
     5  you may not use this file except in compliance with the License.
     6  You may obtain a copy of the License at
     7  
     8  	http://www.apache.org/licenses/LICENSE-2.0
     9  
    10  Unless required by applicable law or agreed to in writing, software
    11  distributed under the License is distributed on an "AS IS" BASIS,
    12  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    13  See the License for the specific language governing permissions and
    14  limitations under the License.
    15  */
    16  
    17  package model
    18  
    19  import (
    20  	"context"
    21  
    22  	"sigs.k8s.io/controller-runtime/pkg/client"
    23  
    24  	"github.com/oam-dev/kubevela/pkg/velaql/providers/query"
    25  	"github.com/oam-dev/kubevela/references/common"
    26  )
    27  
    28  // ManagedResource is managed resource of application
    29  type ManagedResource struct {
    30  	name       string
    31  	namespace  string
    32  	kind       string
    33  	apiVersion string
    34  	cluster    string
    35  	component  string
    36  	status     string
    37  }
    38  
    39  // ManagedResourceList is managed resource list
    40  type ManagedResourceList []ManagedResource
    41  
    42  // ListManagedResource return managed resources of application
    43  func ListManagedResource(ctx context.Context, c client.Client) (ManagedResourceList, error) {
    44  	name := ctx.Value(&CtxKeyAppName).(string)
    45  	namespace := ctx.Value(&CtxKeyNamespace).(string)
    46  	appResList, err := common.ListApplicationResource(c, name, namespace)
    47  	if err != nil {
    48  		return ManagedResourceList{}, err
    49  	}
    50  
    51  	list := make(ManagedResourceList, len(appResList))
    52  
    53  	for index, resource := range appResList {
    54  		list[index] = LoadResourceDetail(resource)
    55  	}
    56  
    57  	cluster, ok := ctx.Value(&CtxKeyCluster).(string)
    58  	if ok && cluster != "" {
    59  		list.FilterCluster(cluster)
    60  	}
    61  
    62  	clusterNamespace, ok := ctx.Value(&CtxKeyClusterNamespace).(string)
    63  	if ok && clusterNamespace != "" {
    64  		list.FilterClusterNamespace(clusterNamespace)
    65  	}
    66  
    67  	return list, nil
    68  }
    69  
    70  // ToTableBody generate header of table in managed resource view
    71  func (l *ManagedResourceList) ToTableBody() [][]string {
    72  	data := make([][]string, 0)
    73  	for _, resource := range *l {
    74  		data = append(data, []string{resource.name, resource.namespace, resource.kind, resource.apiVersion, resource.cluster, resource.component, resource.status})
    75  	}
    76  	return data
    77  }
    78  
    79  // LoadResourceDetail return the aim resource detail info
    80  func LoadResourceDetail(resource query.Resource) ManagedResource {
    81  	if resource.Object == nil {
    82  		return ManagedResource{}
    83  	}
    84  	object := ManagedResource{
    85  		name:       resource.Object.GetName(),
    86  		namespace:  resource.Object.GetNamespace(),
    87  		kind:       resource.Object.GetKind(),
    88  		apiVersion: resource.Object.GetAPIVersion(),
    89  		cluster:    resource.Cluster,
    90  		component:  resource.Component,
    91  	}
    92  	status, err := query.CheckResourceStatus(*resource.Object)
    93  	if err == nil {
    94  		object.status = string(status.Status)
    95  	}
    96  	return object
    97  }
    98  
    99  // FilterCluster filter out objects that belong to the target cluster
   100  func (l *ManagedResourceList) FilterCluster(clusterName string) {
   101  	data := make([]ManagedResource, 0)
   102  	for _, resource := range *l {
   103  		if resource.cluster == clusterName {
   104  			data = append(data, ManagedResource{resource.name, resource.namespace, resource.kind, resource.apiVersion, resource.cluster, resource.component, resource.status})
   105  		}
   106  	}
   107  	*l = data
   108  }
   109  
   110  // FilterClusterNamespace filter out objects that belong to the target namespace
   111  func (l *ManagedResourceList) FilterClusterNamespace(clusterNS string) {
   112  	data := make([]ManagedResource, 0)
   113  	for _, resource := range *l {
   114  		if resource.namespace == clusterNS {
   115  			data = append(data, ManagedResource{resource.name, resource.namespace, resource.kind, resource.apiVersion, resource.cluster, resource.component, resource.status})
   116  		}
   117  	}
   118  	*l = data
   119  }