it works!

Signed-off-by: Ahmet Alp Balkan <[email protected]>

Author: ahmetb

cmd/kubectl-tree/apis.go

@@ -8,45 +8,77 @@ import (
 	"strings"
 )
 
-type resourceMap map[string][]schema.GroupVersionResource // names to apis binding
+type apiResource struct {
+	r  metav1.APIResource
+	gv schema.GroupVersion
+}
 
-func (rm resourceMap) lookup(s string) []schema.GroupVersionResource {
-	return rm[strings.ToLower(s)]
+func (a apiResource) GroupVersionResource() schema.GroupVersionResource {
+	return schema.GroupVersionResource{
+		Group:    a.gv.Group,
+		Version:  a.gv.Version,
+		Resource: a.r.Name,
+	}
 }
 
-func fullAPIName(a schema.GroupVersionResource) string {
-	return strings.Join([]string{a.Resource, a.Version, a.Group}, ".")
+type resourceNameLookup map[string][]apiResource
+
+type resourceMap struct {
+	list []apiResource
+	m    resourceNameLookup
+} // names to apis binding
+
+func (rm *resourceMap) lookup(s string) []apiResource {
+	return rm.m[strings.ToLower(s)]
+}
+
+func (rm *resourceMap) resources() []apiResource { return rm.list }
+
+func fullAPIName(a apiResource) string {
+	sgv := a.GroupVersionResource()
+	return strings.Join([]string{sgv.Resource, sgv.Version, sgv.Group}, ".")
 }
 
-func buildAPILookup(client discovery.DiscoveryInterface) (resourceMap, error) {
+func buildAPILookup(client discovery.DiscoveryInterface) (*resourceMap, error) {
 	resList, err := client.ServerPreferredResources()
 	if err != nil {
 		return nil, fmt.Errorf("failed to fetch api groups from kubernetes: %w", err)
 	}
 
-	nameMap := make(resourceMap)
-
+	rm := &resourceMap{
+		m: make(resourceNameLookup),
+	}
 	for _, group := range resList {
 		gv, err := schema.ParseGroupVersion(group.GroupVersion)
 		if err != nil {
 			return nil, fmt.Errorf("%q cannot be parsed into groupversion: %w", group.GroupVersion, err)
 		}
 
 		for _, apiRes := range group.APIResources {
-			if len(apiRes.Verbs) == 0 {
+			if !contains(apiRes.Verbs, "list") {
 				continue
 			}
 
+			v := apiResource{
+				gv: gv,
+				r:  apiRes,
+			}
 			for _, name := range apiNames(apiRes, gv) {
-				nameMap[name] = append(nameMap[name], schema.GroupVersionResource{
-					Group:    gv.Group,
-					Version:  gv.Version,
-					Resource: apiRes.Name,
-				})
+				rm.m[name] = append(rm.m[name], v)
 			}
+			rm.list = append(rm.list, v)
+		}
+	}
+	return rm, nil
+}
+
+func contains(v []string, s string) bool {
+	for _, vv := range v {
+		if vv == s {
+			return true
 		}
 	}
-	return nameMap, nil
+	return false
 }
 
 // return all names that could refer to this APIResource

cmd/kubectl-tree/query.go

@@ -0,0 +1,56 @@
+package main
+
+import (
+	"fmt"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
+	"k8s.io/client-go/dynamic"
+	"sync"
+)
+
+func QueryResources(client dynamic.Interface, apis []apiResource) ([]unstructured.Unstructured, error) {
+	var mu sync.Mutex
+	var wg sync.WaitGroup
+	var out []unstructured.Unstructured
+
+	var errResult error
+	for _, api := range apis {
+		wg.Add(1)
+		go func(a apiResource) {
+			defer wg.Done()
+			v, err := queryAPI(client, a)
+			if err != nil {
+				errResult = err
+				return
+			}
+			mu.Lock()
+			out = append(out, v...)
+			mu.Unlock()
+		}(api)
+	}
+	wg.Wait()
+	return out, errResult
+}
+
+func queryAPI(client dynamic.Interface, api apiResource) ([]unstructured.Unstructured, error) {
+	var out []unstructured.Unstructured
+
+	var next string
+	for {
+		resp, err := client.Resource(api.GroupVersionResource()).List(metav1.ListOptions{
+			Limit:    250,
+			Continue: next,
+		})
+		if err != nil {
+			return nil, fmt.Errorf("listing resources failed (%s): %w", api.GroupVersionResource(), err)
+		}
+		out = append(out, resp.Items...)
+
+		fmt.Printf("found %d objects in %s (next=%s)\n", len(resp.Items), api.GroupVersionResource(), resp.GetContinue())
+		next = resp.GetContinue()
+		if next == "" {
+			break
+		}
+	}
+	return out, nil
+}

cmd/kubectl-tree/relationship.go

@@ -0,0 +1,38 @@
+package main
+
+import (
+	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
+	"k8s.io/apimachinery/pkg/types"
+)
+
+type objectDirectory struct {
+	items     map[types.UID]unstructured.Unstructured
+	ownership map[types.UID]map[types.UID]bool
+}
+
+func newObjectDirectory(objs []unstructured.Unstructured) objectDirectory {
+	v := objectDirectory{
+		items:     make(map[types.UID]unstructured.Unstructured),
+		ownership: make(map[types.UID]map[types.UID]bool),
+	}
+	for _, obj := range objs {
+		v.items[obj.GetUID()] = obj
+		for _, ownerRef := range obj.GetOwnerReferences() {
+			if v.ownership[ownerRef.UID] == nil {
+				v.ownership[ownerRef.UID] = make(map[types.UID]bool)
+			}
+			v.ownership[ownerRef.UID][obj.GetUID()] = true
+		}
+	}
+	return v
+}
+
+func (od objectDirectory) getObject(id types.UID) unstructured.Unstructured { return od.items[id] }
+
+func (od objectDirectory) ownedBy(ownerID types.UID) []types.UID {
+	var out []types.UID
+	for k := range od.ownership[ownerID] {
+		out = append(out, k)
+	}
+	return out
+}

cmd/kubectl-tree/rootcmd.go

@@ -20,6 +20,7 @@ import (
 	"github.com/spf13/cobra"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/cli-runtime/pkg/genericclioptions"
+	"os"
 	"strings"
 )
 
@@ -39,6 +40,8 @@ func run(cmd *cobra.Command, args []string) error {
 	if err != nil {
 		return err
 	}
+	restConfig.QPS = 1000
+	restConfig.Burst = 1000
 	dyn, err := dynamicClient(restConfig)
 	if err != nil {
 		return err
@@ -65,13 +68,26 @@ func run(cmd *cobra.Command, args []string) error {
 			strings.Join(names, ", "))
 	}
 
-	//namespace := "default" // TODO figure out how to use genericclioptions to read kubeconfig + cli opt
 	fmt.Printf("kind=%#v name=%s\n", apiRes[0], name)
-	result, err := dyn.Resource(apiRes[0]).Get(name, metav1.GetOptions{})
+	if *cf.Namespace == "" {
+		*cf.Namespace = "default" // TODO(ahmetb) figure out how to have this auto-set by kubeconfig w/ cli override
+	}
+
+	obj, err := dyn.Resource(apiRes[0].GroupVersionResource()).Namespace(*cf.Namespace).Get(name, metav1.GetOptions{})
 	if err != nil {
 		return fmt.Errorf("failed to get: %w", err)
 	}
 
-	fmt.Printf("%#v", result)
+	apiObjects, err := QueryResources(dyn, apis.resources())
+	if err != nil {
+		return fmt.Errorf("error while querying api objects: %w", err)
+	}
+	fmt.Printf("%d api objects found\n", len(apiObjects))
+
+	objs := newObjectDirectory(apiObjects)
+	if len(objs.ownership[obj.GetUID()]) == 0 {
+		return fmt.Errorf("no resources are owned by the specified object")
+	}
+	treeView(os.Stderr, objs, *obj)
 	return nil
 }

cmd/kubectl-tree/search.go

@@ -0,0 +1,18 @@
+package main
+
+import (
+	"fmt"
+	"io"
+	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
+)
+
+func treeView(out io.Writer, objs objectDirectory, obj unstructured.Unstructured) {
+	treeViewInner("", out, objs, obj)
+}
+
+func treeViewInner(prefix string, out io.Writer, objs objectDirectory, obj unstructured.Unstructured) {
+	fmt.Fprintf(out, prefix+"%s/%s (#%s#)\n", obj.GetKind(), obj.GetName(),obj.GetUID())
+	for _, child := range objs.ownedBy(obj.GetUID()) {
+		treeViewInner(prefix+"  ", out, objs, objs.getObject(child))
+	}
+}