Aggregated discovery client

Kubernetes-commit: b8fe2c7b8061e6ab0b093a49351bac256606da4a
This commit is contained in:
Sean Sullivan
2022-11-03 11:09:58 -07:00
committed by Kubernetes Publisher
parent 769443557e
commit 25d5761bfa
8 changed files with 3702 additions and 45 deletions

View File

@@ -17,6 +17,9 @@ limitations under the License.
package disk
import (
"encoding/json"
"net/http"
"net/http/httptest"
"os"
"path/filepath"
"strings"
@@ -27,10 +30,12 @@ import (
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
apidiscovery "k8s.io/api/apidiscovery/v2beta1"
"k8s.io/apimachinery/pkg/api/errors"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/runtime"
"k8s.io/apimachinery/pkg/runtime/schema"
"k8s.io/apimachinery/pkg/util/sets"
"k8s.io/apimachinery/pkg/version"
"k8s.io/client-go/discovery"
"k8s.io/client-go/openapi"
@@ -131,13 +136,13 @@ func TestNewCachedDiscoveryClient_PathPerm(t *testing.T) {
// successive calls
func TestOpenAPIDiskCache(t *testing.T) {
// Create discovery cache dir (unused)
discoCache, err := os.MkdirTemp("", "")
discoCache, err := os.MkdirTemp("", "test-cached-discovery-client-disco-*")
require.NoError(t, err)
os.RemoveAll(discoCache)
defer os.RemoveAll(discoCache)
// Create http cache dir
httpCache, err := os.MkdirTemp("", "")
httpCache, err := os.MkdirTemp("", "test-cached-discovery-client-http-*")
require.NoError(t, err)
os.RemoveAll(httpCache)
defer os.RemoveAll(httpCache)
@@ -210,7 +215,6 @@ func TestOpenAPIDiskCache(t *testing.T) {
// Ensure schema call is still served from disk
_, err = newPaths[k].Schema(contentType)
assert.NoError(t, err)
assert.Equal(t, i, fakeServer.RequestCounters["/openapi/v3"])
assert.Equal(t, 1, fakeServer.RequestCounters[path])
}
})
@@ -218,6 +222,481 @@ func TestOpenAPIDiskCache(t *testing.T) {
}
// Tests function "ServerGroups" when the "unaggregated" discovery is returned.
func TestCachedDiscoveryClientUnaggregatedServerGroups(t *testing.T) {
tests := []struct {
name string
corev1 *metav1.APIVersions
apis *metav1.APIGroupList
expectedGroupNames []string
expectedGroupVersions []string
}{
{
name: "Legacy discovery format: 1 version at /api, 1 group at /apis",
corev1: &metav1.APIVersions{
Versions: []string{
"v1",
},
},
apis: &metav1.APIGroupList{
Groups: []metav1.APIGroup{
{
Name: "extensions",
Versions: []metav1.GroupVersionForDiscovery{
{GroupVersion: "extensions/v1beta1"},
},
},
},
},
expectedGroupNames: []string{"", "extensions"},
expectedGroupVersions: []string{"v1", "extensions/v1beta1"},
},
{
name: "Legacy discovery format: 1 version at /api, 2 groups/1 version at /apis",
corev1: &metav1.APIVersions{
Versions: []string{
"v1",
},
},
apis: &metav1.APIGroupList{
Groups: []metav1.APIGroup{
{
Name: "apps",
Versions: []metav1.GroupVersionForDiscovery{
{GroupVersion: "apps/v1"},
},
},
{
Name: "extensions",
Versions: []metav1.GroupVersionForDiscovery{
{GroupVersion: "extensions/v1beta1"},
},
},
},
},
expectedGroupNames: []string{"", "apps", "extensions"},
expectedGroupVersions: []string{"v1", "apps/v1", "extensions/v1beta1"},
},
{
name: "Legacy discovery format: 1 version at /api, 2 groups/2 versions at /apis",
corev1: &metav1.APIVersions{
Versions: []string{
"v1",
},
},
apis: &metav1.APIGroupList{
Groups: []metav1.APIGroup{
{
Name: "batch",
Versions: []metav1.GroupVersionForDiscovery{
{GroupVersion: "batch/v1"},
},
},
{
Name: "batch",
Versions: []metav1.GroupVersionForDiscovery{
{GroupVersion: "batch/v1beta1"},
},
},
{
Name: "extensions",
Versions: []metav1.GroupVersionForDiscovery{
{GroupVersion: "extensions/v1beta1"},
},
},
{
Name: "extensions",
Versions: []metav1.GroupVersionForDiscovery{
{GroupVersion: "extensions/v1alpha1"},
},
},
},
},
expectedGroupNames: []string{
"",
"batch",
"extensions",
},
expectedGroupVersions: []string{
"v1",
"batch/v1",
"batch/v1beta1",
"extensions/v1beta1",
"extensions/v1alpha1",
},
},
}
for _, test := range tests {
// Create discovery cache dir
discoCache, err := os.MkdirTemp("", "test-cached-discovery-client-disco-*")
require.NoError(t, err)
os.RemoveAll(discoCache)
defer os.RemoveAll(discoCache)
// Create http cache dir (unused)
httpCache, err := os.MkdirTemp("", "test-cached-discovery-client-http-*")
require.NoError(t, err)
os.RemoveAll(httpCache)
defer os.RemoveAll(httpCache)
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
var body interface{}
switch req.URL.Path {
case "/api":
body = test.corev1
case "/apis":
body = test.apis
default:
w.WriteHeader(http.StatusNotFound)
return
}
output, err := json.Marshal(body)
require.NoError(t, err)
// Content-type is "unaggregated" discovery format -- no resources returned.
w.Header().Set("Content-Type", discovery.AcceptV1)
w.WriteHeader(http.StatusOK)
w.Write(output)
}))
defer server.Close()
client, err := NewCachedDiscoveryClientForConfig(
&restclient.Config{Host: server.URL},
discoCache,
httpCache,
1*time.Nanosecond,
)
require.NoError(t, err)
apiGroupList, err := client.ServerGroups()
require.NoError(t, err)
// Discovery groups cached in servergroups.json file.
numFound, err := numFilesFound(discoCache, "servergroups.json")
assert.NoError(t, err)
assert.Equal(t, 1, numFound,
"%s: expected 1 discovery cache file servergroups.json found, got %d", test.name, numFound)
// Test expected groups returned by server groups.
expectedGroupNames := sets.NewString(test.expectedGroupNames...)
actualGroupNames := sets.NewString(groupNamesFromList(apiGroupList)...)
assert.True(t, expectedGroupNames.Equal(actualGroupNames),
"%s: Expected groups (%s), got (%s)", test.name, expectedGroupNames.List(), actualGroupNames.List())
// Test the expected group versions for the aggregated discovery is correct.
expectedGroupVersions := sets.NewString(test.expectedGroupVersions...)
actualGroupVersions := sets.NewString(groupVersionsFromGroups(apiGroupList)...)
assert.True(t, expectedGroupVersions.Equal(actualGroupVersions),
"%s: Expected group/versions (%s), got (%s)", test.name, expectedGroupVersions.List(), actualGroupVersions.List())
}
}
// Aggregated discovery format returned
func TestCachedDiscoveryClientAggregatedServerGroups(t *testing.T) {
tests := []struct {
name string
corev1 *apidiscovery.APIGroupDiscoveryList
apis *apidiscovery.APIGroupDiscoveryList
expectedGroupNames []string
expectedGroupVersions []string
expectedPreferredVersions []string
}{
{
name: "Aggregated cached discovery: 1 group/1 version at /api, 1 group/1 version at /apis",
corev1: &apidiscovery.APIGroupDiscoveryList{
Items: []apidiscovery.APIGroupDiscovery{
{
Versions: []apidiscovery.APIVersionDiscovery{
{
Version: "v1",
Resources: []apidiscovery.APIResourceDiscovery{
{
Resource: "pods",
ResponseKind: &metav1.GroupVersionKind{
Group: "",
Version: "v1",
Kind: "Pod",
},
Scope: apidiscovery.ScopeNamespace,
},
},
},
},
},
},
},
apis: &apidiscovery.APIGroupDiscoveryList{
Items: []apidiscovery.APIGroupDiscovery{
{
ObjectMeta: metav1.ObjectMeta{
Name: "apps",
},
Versions: []apidiscovery.APIVersionDiscovery{
{
Version: "v1",
Resources: []apidiscovery.APIResourceDiscovery{
{
Resource: "deployments",
ResponseKind: &metav1.GroupVersionKind{
Group: "apps",
Version: "v1",
Kind: "Deployment",
},
Scope: apidiscovery.ScopeNamespace,
},
},
},
},
},
},
},
expectedGroupNames: []string{"", "apps"},
expectedGroupVersions: []string{"v1", "apps/v1"},
expectedPreferredVersions: []string{"v1", "apps/v1"},
},
{
name: "Aggregated discovery: 1 group/1 version at /api, 1 group/2 versions at /apis",
corev1: &apidiscovery.APIGroupDiscoveryList{
Items: []apidiscovery.APIGroupDiscovery{
{
ObjectMeta: metav1.ObjectMeta{
Name: "",
},
Versions: []apidiscovery.APIVersionDiscovery{
{
Version: "v1",
Resources: []apidiscovery.APIResourceDiscovery{
{
Resource: "pods",
ResponseKind: &metav1.GroupVersionKind{
Group: "",
Version: "v1",
Kind: "Pod",
},
Scope: apidiscovery.ScopeNamespace,
},
},
},
},
},
},
},
apis: &apidiscovery.APIGroupDiscoveryList{
Items: []apidiscovery.APIGroupDiscovery{
{
ObjectMeta: metav1.ObjectMeta{
Name: "apps",
},
Versions: []apidiscovery.APIVersionDiscovery{
// v2 is preferred since it is first
{
Version: "v2",
Resources: []apidiscovery.APIResourceDiscovery{
{
Resource: "deployments",
ResponseKind: &metav1.GroupVersionKind{
Group: "apps",
Version: "v2",
Kind: "Deployment",
},
Scope: apidiscovery.ScopeNamespace,
},
},
},
{
Version: "v1",
Resources: []apidiscovery.APIResourceDiscovery{
{
Resource: "deployments",
ResponseKind: &metav1.GroupVersionKind{
Group: "apps",
Version: "v1",
Kind: "Deployment",
},
Scope: apidiscovery.ScopeNamespace,
},
},
},
},
},
},
},
expectedGroupNames: []string{"", "apps"},
expectedGroupVersions: []string{"v1", "apps/v1", "apps/v2"},
expectedPreferredVersions: []string{"v1", "apps/v2"},
},
{
name: "Aggregated discovery: /api returns nothing, 2 groups at /apis",
corev1: &apidiscovery.APIGroupDiscoveryList{},
apis: &apidiscovery.APIGroupDiscoveryList{
Items: []apidiscovery.APIGroupDiscovery{
{
ObjectMeta: metav1.ObjectMeta{
Name: "apps",
},
Versions: []apidiscovery.APIVersionDiscovery{
{
Version: "v1",
Resources: []apidiscovery.APIResourceDiscovery{
{
Resource: "deployments",
ResponseKind: &metav1.GroupVersionKind{
Group: "apps",
Version: "v1",
Kind: "Deployment",
},
Scope: apidiscovery.ScopeNamespace,
},
{
Resource: "statefulsets",
ResponseKind: &metav1.GroupVersionKind{
Group: "apps",
Version: "v1",
Kind: "StatefulSet",
},
Scope: apidiscovery.ScopeNamespace,
},
},
},
},
},
{
ObjectMeta: metav1.ObjectMeta{
Name: "batch",
},
Versions: []apidiscovery.APIVersionDiscovery{
// v1 is preferred since it is first
{
Version: "v1",
Resources: []apidiscovery.APIResourceDiscovery{
{
Resource: "jobs",
ResponseKind: &metav1.GroupVersionKind{
Group: "batch",
Version: "v1",
Kind: "Job",
},
Scope: apidiscovery.ScopeNamespace,
},
{
Resource: "cronjobs",
ResponseKind: &metav1.GroupVersionKind{
Group: "batch",
Version: "v1",
Kind: "CronJob",
},
Scope: apidiscovery.ScopeNamespace,
},
},
},
{
Version: "v1beta1",
Resources: []apidiscovery.APIResourceDiscovery{
{
Resource: "jobs",
ResponseKind: &metav1.GroupVersionKind{
Group: "batch",
Version: "v1beta1",
Kind: "Job",
},
Scope: apidiscovery.ScopeNamespace,
},
{
Resource: "cronjobs",
ResponseKind: &metav1.GroupVersionKind{
Group: "batch",
Version: "v1beta1",
Kind: "CronJob",
},
Scope: apidiscovery.ScopeNamespace,
},
},
},
},
},
},
},
expectedGroupNames: []string{"apps", "batch"},
expectedGroupVersions: []string{"apps/v1", "batch/v1", "batch/v1beta1"},
expectedPreferredVersions: []string{"apps/v1", "batch/v1"},
},
}
for _, test := range tests {
// Create discovery cache dir
discoCache, err := os.MkdirTemp("", "test-cached-discovery-client-disco-*")
require.NoError(t, err)
os.RemoveAll(discoCache)
defer os.RemoveAll(discoCache)
// Create http cache dir (unused)
httpCache, err := os.MkdirTemp("", "test-cached-discovery-client-http-*")
require.NoError(t, err)
os.RemoveAll(httpCache)
defer os.RemoveAll(httpCache)
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
var agg *apidiscovery.APIGroupDiscoveryList
switch req.URL.Path {
case "/api":
agg = test.corev1
case "/apis":
agg = test.apis
default:
w.WriteHeader(http.StatusNotFound)
return
}
output, err := json.Marshal(agg)
if err != nil {
t.Fatalf("unexpected encoding error: %v", err)
return
}
// Content-type is "aggregated" discovery format.
w.Header().Set("Content-Type", discovery.AcceptV2Beta1)
w.WriteHeader(http.StatusOK)
w.Write(output)
}))
defer server.Close()
client, err := NewCachedDiscoveryClientForConfig(
&restclient.Config{Host: server.URL},
discoCache,
httpCache,
1*time.Nanosecond,
)
require.NoError(t, err)
apiGroupList, err := client.ServerGroups()
require.NoError(t, err)
// Discovery groups cached in servergroups.json file.
numFound, err := numFilesFound(discoCache, "servergroups.json")
assert.NoError(t, err)
assert.Equal(t, 1, numFound,
"%s: expected 1 discovery cache file servergroups.json found, got %d", test.name, numFound)
// Test expected groups returned by server groups.
expectedGroupNames := sets.NewString(test.expectedGroupNames...)
actualGroupNames := sets.NewString(groupNamesFromList(apiGroupList)...)
assert.True(t, expectedGroupNames.Equal(actualGroupNames),
"%s: Expected groups (%s), got (%s)", test.name, expectedGroupNames.List(), actualGroupNames.List())
// Test the expected group versions for the aggregated discovery is correct.
expectedGroupVersions := sets.NewString(test.expectedGroupVersions...)
actualGroupVersions := sets.NewString(groupVersionsFromGroups(apiGroupList)...)
assert.True(t, expectedGroupVersions.Equal(actualGroupVersions),
"%s: Expected group/versions (%s), got (%s)", test.name, expectedGroupVersions.List(), actualGroupVersions.List())
// Test the groups preferred version is correct.
expectedPreferredVersions := sets.NewString(test.expectedPreferredVersions...)
actualPreferredVersions := sets.NewString(preferredVersionsFromList(apiGroupList)...)
assert.True(t, expectedPreferredVersions.Equal(actualPreferredVersions),
"%s: Expected preferred group/version (%s), got (%s)", test.name, expectedPreferredVersions.List(), actualPreferredVersions.List())
}
}
func numFilesFound(dir string, filename string) (int, error) {
numFound := 0
err := filepath.Walk(dir, func(path string, info os.FileInfo, err error) error {
if err != nil {
return err
}
if info.Name() == filename {
numFound++
}
return nil
})
if err != nil {
return 0, err
}
return numFound, nil
}
type fakeDiscoveryClient struct {
groupCalls int
resourceCalls int
@@ -306,3 +785,30 @@ func (c *fakeDiscoveryClient) OpenAPISchema() (*openapi_v2.Document, error) {
func (d *fakeDiscoveryClient) OpenAPIV3() openapi.Client {
panic("unimplemented")
}
func groupNamesFromList(groups *metav1.APIGroupList) []string {
result := []string{}
for _, group := range groups.Groups {
result = append(result, group.Name)
}
return result
}
func preferredVersionsFromList(groups *metav1.APIGroupList) []string {
result := []string{}
for _, group := range groups.Groups {
preferredGV := group.PreferredVersion.GroupVersion
result = append(result, preferredGV)
}
return result
}
func groupVersionsFromGroups(groups *metav1.APIGroupList) []string {
result := []string{}
for _, group := range groups.Groups {
for _, version := range group.Versions {
result = append(result, version.GroupVersion)
}
}
return result
}