feat: check required api resources

coder · johnstcn · Aug 27, 2021 · Aug 25, 2021 · Aug 26, 2021 · Aug 26, 2021
commit dc3d8fdfb08ad01bb739feb28a905f757dfc3b5d
diff --git a/internal/checks/kube/resources.go b/internal/checks/kube/resources.go
@@ -2,11 +2,60 @@ package kube
 
 import (
 	"context"
+	"fmt"
+
+	"golang.org/x/xerrors"
+	"k8s.io/apimachinery/pkg/runtime/schema"
 
 	"github.com/cdr/coder-doctor/internal/api"
 )
 
-func (k *KubernetesChecker) CheckResources(ctx context.Context) []*api.CheckResult {
+func (k *KubernetesChecker) CheckResources(_ context.Context) []*api.CheckResult {
+	const checkName = "kubernetes-resources"
 	results := make([]*api.CheckResult, 0)
+	dc := k.client.Discovery()
+	lists, err := dc.ServerPreferredResources()
+	if err != nil {
+		results = append(results, api.ErrorResult(checkName, "unable to fetch api resources from server", err))
+		return results
+	}
+
+	resourcesAvailable := make(map[ResourceRequirement]bool)
+	for _, list := range lists {
+		if len(list.APIResources) == 0 {
+			continue
+		}
+
+		gv, err := schema.ParseGroupVersion(list.GroupVersion)
+		if err != nil {
+			continue
+		}
+
+		for _, resource := range list.APIResources {
+			if len(resource.Verbs) == 0 {
+				continue
+			}
+
+			r := ResourceRequirement{
+				Group:    gv.Group,
+				Version:  gv.String(),
+				Resource: resource.Name,
+			}
+			resourcesAvailable[r] = true
+		}
+	}
+
+	versionReqs := findClosestVersionRequirements(k.coderVersion)
+	for versionReq := range versionReqs {
+		if !resourcesAvailable[*versionReq] {
+			msg := fmt.Sprintf("missing required resource:%q group:%q version:%q", versionReq.Resource, versionReq.Group, versionReq.Version)
+			errResult := api.ErrorResult(checkName, msg, xerrors.New(msg))
+			results = append(results, errResult)
+			continue
+		}
+		msg := fmt.Sprintf("found required resource:%q group:%q version:%q", versionReq.Resource, versionReq.Group, versionReq.Version)
+		results = append(results, api.PassResult(checkName, msg))
+	}
+
 	return results
 }
diff --git a/internal/checks/kube/resources_list.go b/internal/checks/kube/resources_list.go
@@ -10,16 +10,16 @@ var allRequirements = []VersionedResourceRequirements{
 	{
 		VersionConstraints: api.MustConstraint(">= 1.20"),
 		ResourceRequirements: map[*ResourceRequirement]ResourceVerbs{
-			NewResourceRequirement("", "v1", "pods"):                                   verbsCreateDeleteList,
-			NewResourceRequirement("", "v1", "secrets"):                                verbsCreateDeleteList,
-			NewResourceRequirement("", "v1", "serviceaccounts"):                        verbsCreateDeleteList,
-			NewResourceRequirement("", "v1", "services"):                               verbsCreateDeleteList,
-			NewResourceRequirement("", "rbac.authorization.k8s.io/v1", "roles"):        verbsCreateDeleteList,
-			NewResourceRequirement("", "rbac.authorization.k8s.io/v1", "rolebindings"): verbsCreateDeleteList,
-			NewResourceRequirement("apps", "apps/v1", "deployments"):                   verbsCreateDeleteList,
-			NewResourceRequirement("apps", "apps/v1", "replicasets"):                   verbsCreateDeleteList,
-			NewResourceRequirement("apps", "apps/v1", "statefulsets"):                  verbsCreateDeleteList,
-			NewResourceRequirement("extensions", "ingresses", "networking.k8s.io/v1"):  verbsCreateDeleteList,
+			NewResourceRequirement("", "v1", "pods"):                                                            verbsCreateDeleteList,
+			NewResourceRequirement("", "v1", "secrets"):                                                         verbsCreateDeleteList,
+			NewResourceRequirement("", "v1", "serviceaccounts"):                                                 verbsCreateDeleteList,
+			NewResourceRequirement("", "v1", "services"):                                                        verbsCreateDeleteList,
+			NewResourceRequirement("apps", "apps/v1", "deployments"):                                            verbsCreateDeleteList,
+			NewResourceRequirement("apps", "apps/v1", "replicasets"):                                            verbsCreateDeleteList,
+			NewResourceRequirement("apps", "apps/v1", "statefulsets"):                                           verbsCreateDeleteList,
+			NewResourceRequirement("networking.k8s.io", "networking.k8s.io/v1", "ingresses"):                    verbsCreateDeleteList,
+			NewResourceRequirement("rbac.authorization.k8s.io", "rbac.authorization.k8s.io/v1", "roles"):        verbsCreateDeleteList,
+			NewResourceRequirement("rbac.authorization.k8s.io", "rbac.authorization.k8s.io/v1", "rolebindings"): verbsCreateDeleteList,
 		},
 	},
 }
@@ -37,8 +37,8 @@ type ResourceVerbs []string
 
 // VersionedResourceRequirements is a set of ResourceRequirements for a specific version of Coder.
 type VersionedResourceRequirements struct {
-	VersionConstraints *semver.Constraints
-	ResourceRequirements   map[*ResourceRequirement]ResourceVerbs
+	VersionConstraints   *semver.Constraints
+	ResourceRequirements map[*ResourceRequirement]ResourceVerbs
 }
 
 var verbsCreateDeleteList ResourceVerbs = []string{"create", "delete", "list"}

diff --git a/internal/checks/kube/resources_test.go b/internal/checks/kube/resources_test.go
@@ -2,7 +2,9 @@ package kube
 
 import (
 	"context"
+	"encoding/json"
 	"net/http"
+	"net/http/httptest"
 	"testing"
 
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
@@ -17,13 +19,24 @@ func Test_KubernetesChecker_CheckResources(t *testing.T) {
 	t.Parallel()
 
 	tests := []struct {
-		Name     string
-		Response *metav1.APIResourceList
-		F        func(*testing.T, []*api.CheckResult)
+		Name              string
+		GroupListResponse *metav1.APIGroupList
+		F                 func(*testing.T, []*api.CheckResult)
 	}{
 		{
-			Name:     "no resources available",
-			Response: emptyAPIResourceList,
+			Name:              "all resources available",
+			GroupListResponse: fullAPIGroupList,
+			F: func(t *testing.T, results []*api.CheckResult) {
+				assert.False(t, "results should not be empty", len(results) == 0)
+				for _, result := range results {
+					assert.Equal(t, result.Name+" should have no error", nil, result.Details["error"])
+					assert.Equal(t, result.Name+" should pass", api.StatePassed, result.State)
+				}
+			},
+		},
+		{
+			Name:              "no resources available",
+			GroupListResponse: emptyAPIGroupList,
 			F: func(t *testing.T, results []*api.CheckResult) {
 				assert.False(t, "results should not be empty", len(results) == 0)
 				for _, result := range results {
@@ -41,7 +54,33 @@ func Test_KubernetesChecker_CheckResources(t *testing.T) {
 		t.Run(test.Name, func(t *testing.T) {
 			t.Parallel()
 
-			server := newTestHTTPServer(t, http.StatusOK, test.Response)
+			server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
+				w.Header().Set("Content-Type", "application/json")
+				switch req.URL.Path {
+				case "/apis":
+					w.WriteHeader(http.StatusOK)
+					err := json.NewEncoder(w).Encode(test.GroupListResponse)
+					assert.Success(t, "failed to encode response", err)
+				case "/api/v1":
+					w.WriteHeader(http.StatusOK)
+					err := json.NewEncoder(w).Encode(v1ResourceList)
+					assert.Success(t, "failed to encode response", err)
+				case "/apis/apps/v1":
+					w.WriteHeader(http.StatusOK)
+					err := json.NewEncoder(w).Encode(appsV1ResourceList)
+					assert.Success(t, "failed to encode response", err)
+				case "/apis/networking.k8s.io/v1":
+					w.WriteHeader(http.StatusOK)
+					err := json.NewEncoder(w).Encode(networkingV1ResourceList)
+					assert.Success(t, "failed to encode response", err)
+				case "/apis/rbac.authorization.k8s.io/v1":
+					w.WriteHeader(http.StatusOK)
+					err := json.NewEncoder(w).Encode(rbacV1ResourceList)
+					assert.Success(t, "failed to encode response", err)
+				default:
+					w.WriteHeader(http.StatusNotFound)
+				}
+			}))
 			defer server.Close()
 
 			client, err := kubernetes.NewForConfig(&rest.Config{Host: server.URL})
@@ -54,8 +93,133 @@ func Test_KubernetesChecker_CheckResources(t *testing.T) {
 	}
 }
 
-var emptyAPIResourceList *metav1.APIResourceList = &metav1.APIResourceList{
-	TypeMeta:     metav1.TypeMeta{},
-	GroupVersion: "",
-	APIResources: []metav1.APIResource{},
+var emptyAPIGroupList *metav1.APIGroupList = &metav1.APIGroupList{
+	TypeMeta: metav1.TypeMeta{
+		Kind:       "APIGroupList",
+		APIVersion: "v1",
+	},
+	Groups: []metav1.APIGroup{},
+}
+
+var fullAPIGroupList *metav1.APIGroupList = &metav1.APIGroupList{
+	TypeMeta: metav1.TypeMeta{
+		Kind:       "APIGroupList",
+		APIVersion: "v1",
+	},
+	Groups: []metav1.APIGroup{
+		{
+			Versions: []metav1.GroupVersionForDiscovery{
+				{
+					GroupVersion: "v1",
+					Version:      "v1",
+				},
+			},
+		},
+		{
+			Name: "apps",
+			Versions: []metav1.GroupVersionForDiscovery{
+				{
+					GroupVersion: "apps/v1",
+					Version:      "v1",
+				},
+			},
+		},
+		{
+			Name: "networking.k8s.io",
+			Versions: []metav1.GroupVersionForDiscovery{
+				{
+					GroupVersion: "networking.k8s.io/v1",
+					Version:      "v1",
+				},
+			},
+		},
+		{
+			Name: "rbac.authorization.k8s.io",
+			Versions: []metav1.GroupVersionForDiscovery{
+				{
+					GroupVersion: "rbac.authorization.k8s.io/v1",
+					Version:      "v1",
+				},
+			},
+		},
+	},
+}
+
+var v1ResourceList = &metav1.APIResourceList{
+	TypeMeta: metav1.TypeMeta{
+		Kind: "APIResourceList",
+	},
+	GroupVersion: "v1",
+	APIResources: []metav1.APIResource{
+		{
+			Name:  "pods",
+			Verbs: []string{"get"},
+		},
+		{
+			Name:  "secrets",
+			Verbs: []string{"get"},
+		},
+		{
+			Name:  "serviceaccounts",
+			Verbs: []string{"get"},
+		},
+		{
+			Name:  "services",
+			Verbs: []string{"get"},
+		},
+	},
+}
+
+var appsV1ResourceList = &metav1.APIResourceList{
+	TypeMeta: metav1.TypeMeta{
+		Kind:       "APIResourceList",
+		APIVersion: "v1",
+	},
+	GroupVersion: "apps/v1",
+	APIResources: []metav1.APIResource{
+		{
+			Name:  "deployments",
+			Verbs: []string{"get"},
+		},
+		{
+			Name:  "replicasets",
+			Verbs: []string{"get"},
+		},
+		{
+			Name:  "statefulsets",
+			Verbs: []string{"get"},
+		},
+	},
+}
+
+var networkingV1ResourceList = &metav1.APIResourceList{
+	TypeMeta: metav1.TypeMeta{
+		Kind:       "APIResourceList",
+		APIVersion: "v1",
+	},
+	GroupVersion: "networking.k8s.io/v1",
+	APIResources: []metav1.APIResource{
+		{
+			Name:  "ingresses",
+			Verbs: []string{"get"},
+		},
+	},
+}
+
+var rbacV1ResourceList = &metav1.APIResourceList{
+	TypeMeta: metav1.TypeMeta{
+		Kind:       "APIResourceList",
+		APIVersion: "v1",
+	},
+	GroupVersion: "rbac.authorization.k8s.io/v1",
+	APIResources: []metav1.APIResource{
+		{
+			Name:  "roles",
+			Verbs: []string{"get"},
+		},
+		{
+			Name:  "rolebindings",
+			Verbs: []string{"get"},
+		},
+	},
 }