Merge pull request #3539 from xrstf/kubectl-backwards-bc

Implement wrappers in CLI module to allow working with older API versions

Author: kcp-ci-bot

cli/pkg/bind/plugin/bind.go

@@ -27,6 +27,7 @@ import (
 	"github.com/spf13/cobra"
 
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/runtime/schema"
 	"k8s.io/apimachinery/pkg/util/wait"
 	"k8s.io/cli-runtime/pkg/genericclioptions"
 	"k8s.io/client-go/rest"
@@ -35,6 +36,9 @@ import (
 
 	"github.com/kcp-dev/kcp/cli/pkg/base"
 	pluginhelpers "github.com/kcp-dev/kcp/cli/pkg/helpers"
+	apishelpers "github.com/kcp-dev/kcp/cli/pkg/helpers/apis/apis"
+	"github.com/kcp-dev/kcp/sdk/apis/apis"
+	apisv1alpha1 "github.com/kcp-dev/kcp/sdk/apis/apis/v1alpha1"
 	apisv1alpha2 "github.com/kcp-dev/kcp/sdk/apis/apis/v1alpha2"
 	kcpclientset "github.com/kcp-dev/kcp/sdk/client/clientset/versioned/cluster"
 )
@@ -143,77 +147,114 @@ func (b *BindOptions) Run(ctx context.Context) error {
 		return err
 	}
 
-	path, apiExportName := logicalcluster.NewPath(b.APIExportRef).Split()
-
-	// if a custom name is not provided, default it to <apiExportname>.
-	apiBindingName := b.APIBindingName
-	if apiBindingName == "" {
-		apiBindingName = apiExportName
-	}
-
 	_, currentClusterName, err := pluginhelpers.ParseClusterURL(config.Host)
 	if err != nil {
 		return fmt.Errorf("current URL %q does not point to workspace", config.Host)
 	}
 
-	binding := &apisv1alpha2.APIBinding{
-		ObjectMeta: metav1.ObjectMeta{
-			Name: apiBindingName,
-		},
-		Spec: apisv1alpha2.APIBindingSpec{
-			Reference: apisv1alpha2.BindingReference{
-				Export: &apisv1alpha2.ExportBindingReference{
-					Path: path.String(),
-					Name: apiExportName,
-				},
-			},
-		},
+	preferredAPIBindingVersion, err := pluginhelpers.PreferredVersion(config, schema.GroupResource{
+		Group:    apis.GroupName,
+		Resource: "apibindings",
+	})
+	if err != nil {
+		return fmt.Errorf("service discovery failed: %w", err)
 	}
 
-	if len(b.acceptedPermissionClaims) > 0 {
-		binding.Spec.PermissionClaims = b.acceptedPermissionClaims
-	}
-	if len(b.rejectedPermissionClaims) > 0 {
-		binding.Spec.PermissionClaims = append(binding.Spec.PermissionClaims, b.rejectedPermissionClaims...)
+	apiBinding, err := b.newAPIBinding(preferredAPIBindingVersion)
+	if err != nil {
+		return fmt.Errorf("failed to create APIBinding: %w", err)
 	}
 
-	kcpclient, err := newKCPClusterClient(config)
+	kcpClusterClient, err := newKCPClusterClient(config)
 	if err != nil {
 		return err
 	}
 
-	createdBinding, err := kcpclient.Cluster(currentClusterName).ApisV1alpha2().APIBindings().Create(ctx, binding, metav1.CreateOptions{})
-	if err != nil {
-		return err
+	if err := apiBinding.Create(ctx, kcpClusterClient.Cluster(currentClusterName)); err != nil {
+		return fmt.Errorf("failed to create APIBinding: %w", err)
 	}
 
-	if _, err := fmt.Fprintf(b.Out, "apibinding %s created. Waiting to successfully bind ...\n", binding.Name); err != nil {
+	if _, err := fmt.Fprintf(b.Out, "apibinding %s created. Waiting to successfully bind ...\n", apiBinding.Name()); err != nil {
 		return err
 	}
 
 	// wait for phase to be bound
-	if createdBinding.Status.Phase != apisv1alpha2.APIBindingPhaseBound {
-		if err := wait.PollUntilContextTimeout(ctx, time.Millisecond*500, b.BindWaitTimeout, true, func(ctx context.Context) (done bool, err error) {
-			createdBinding, err := kcpclient.Cluster(currentClusterName).ApisV1alpha2().APIBindings().Get(ctx, binding.Name, metav1.GetOptions{})
-			if err != nil {
+	if !apiBinding.IsBound() {
+		if err := wait.PollUntilContextTimeout(ctx, time.Millisecond*500, b.BindWaitTimeout, true, func(ctx context.Context) (bool, error) {
+			if err := apiBinding.Refresh(ctx, kcpClusterClient.Cluster(currentClusterName)); err != nil {
 				return false, err
 			}
-			if createdBinding.Status.Phase == apisv1alpha2.APIBindingPhaseBound {
-				return true, nil
-			}
-			return false, nil
+
+			return apiBinding.IsBound(), nil
 		}); err != nil {
-			return fmt.Errorf("could not bind %s: %w", binding.Name, err)
+			return fmt.Errorf("could not bind %s: %w", apiBinding.Name(), err)
 		}
 	}
 
-	if _, err := fmt.Fprintf(b.Out, "%s created and bound.\n", binding.Name); err != nil {
+	if _, err := fmt.Fprintf(b.Out, "%s created and bound.\n", apiBinding.Name()); err != nil {
 		return err
 	}
 
 	return nil
 }
 
+func (b *BindOptions) newAPIBinding(preferredAPIBindingVersion string) (apishelpers.APIBinding, error) {
+	path, apiExportName := logicalcluster.NewPath(b.APIExportRef).Split()
+
+	// if a custom name is not provided, default it to <apiExportname>.
+	apiBindingName := b.APIBindingName
+	if apiBindingName == "" {
+		apiBindingName = apiExportName
+	}
+
+	var binding apishelpers.APIBinding
+
+	switch preferredAPIBindingVersion {
+	case "v1alpha2":
+		binding = apishelpers.NewAPIBinding(&apisv1alpha2.APIBinding{
+			ObjectMeta: metav1.ObjectMeta{
+				Name: apiBindingName,
+			},
+			Spec: apisv1alpha2.APIBindingSpec{
+				Reference: apisv1alpha2.BindingReference{
+					Export: &apisv1alpha2.ExportBindingReference{
+						Path: path.String(),
+						Name: apiExportName,
+					},
+				},
+			},
+		})
+
+	case "v1alpha1":
+		binding = apishelpers.NewAPIBinding(&apisv1alpha1.APIBinding{
+			ObjectMeta: metav1.ObjectMeta{
+				Name: apiBindingName,
+			},
+			Spec: apisv1alpha1.APIBindingSpec{
+				Reference: apisv1alpha1.BindingReference{
+					Export: &apisv1alpha1.ExportBindingReference{
+						Path: path.String(),
+						Name: apiExportName,
+					},
+				},
+			},
+		})
+
+	default:
+		return nil, fmt.Errorf("%s is not supported by this plugin", preferredAPIBindingVersion)
+	}
+
+	claims := []apisv1alpha2.AcceptablePermissionClaim{}
+	claims = append(claims, b.acceptedPermissionClaims...)
+	claims = append(claims, b.rejectedPermissionClaims...)
+
+	if err := binding.SetPermissionClaims(claims); err != nil {
+		return nil, fmt.Errorf("invalid permission claims: %w", err)
+	}
+
+	return binding, nil
+}
+
 func (b *BindOptions) parsePermissionClaim(claim string, accepted bool) error {
 	claimParts := strings.SplitN(claim, ".", 2)
 	if len(claimParts) != 2 {

cli/pkg/claims/plugin/claims.go

@@ -19,22 +19,20 @@ package plugin
 import (
 	"context"
 	"fmt"
-	"io"
 	"net/url"
-	"strings"
 
 	"github.com/spf13/cobra"
 
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	utilerrors "k8s.io/apimachinery/pkg/util/errors"
+	"k8s.io/apimachinery/pkg/runtime/schema"
 	"k8s.io/cli-runtime/pkg/genericclioptions"
 	"k8s.io/cli-runtime/pkg/printers"
 	"k8s.io/client-go/rest"
 	"k8s.io/client-go/tools/clientcmd"
 
 	"github.com/kcp-dev/kcp/cli/pkg/base"
 	pluginhelpers "github.com/kcp-dev/kcp/cli/pkg/helpers"
-	apiv1alpha2 "github.com/kcp-dev/kcp/sdk/apis/apis/v1alpha2"
+	apishelpers "github.com/kcp-dev/kcp/cli/pkg/helpers/apis/apis"
+	"github.com/kcp-dev/kcp/sdk/apis/apis"
 	kcpclientset "github.com/kcp-dev/kcp/sdk/client/clientset/versioned/cluster"
 )
 
@@ -90,6 +88,14 @@ func (g *GetAPIBindingOptions) Run(ctx context.Context) error {
 		return fmt.Errorf("current URL %q does not point to workspace", cfg.Host)
 	}
 
+	preferredAPIBindingVersion, err := pluginhelpers.PreferredVersion(cfg, schema.GroupResource{
+		Group:    apis.GroupName,
+		Resource: "apibindings",
+	})
+	if err != nil {
+		return fmt.Errorf("service discovery failed: %w", err)
+	}
+
 	kcpClusterClient, err := newKCPClusterClient(g.ClientConfig)
 	if err != nil {
 		return fmt.Errorf("error while creating kcp client %w", err)
@@ -98,38 +104,24 @@ func (g *GetAPIBindingOptions) Run(ctx context.Context) error {
 	out := printers.GetNewTabWriter(g.Out)
 	defer out.Flush()
 
-	err = printHeaders(out)
-	if err != nil {
-		return fmt.Errorf("error: %w", err)
-	}
-
-	allErrors := []error{}
-	apibindings := []apiv1alpha2.APIBinding{}
 	// List permission claims for all bindings in current workspace.
+
+	var bindingsList apishelpers.APIBindingList
 	if g.allBindings {
-		bindings, err := kcpClusterClient.Cluster(currentClusterName).ApisV1alpha2().APIBindings().List(ctx, metav1.ListOptions{})
+		bindings, err := apishelpers.ListAPIBindings(ctx, kcpClusterClient.Cluster(currentClusterName), preferredAPIBindingVersion)
 		if err != nil {
-			return fmt.Errorf("error listing apibindings in %q workspace: %w", currentClusterName, err)
+			return fmt.Errorf("error listing APIBindings in %q workspace: %w", currentClusterName, err)
 		}
-		apibindings = append(apibindings, bindings.Items...)
+		bindingsList = bindings
 	} else {
-		binding, err := kcpClusterClient.Cluster(currentClusterName).ApisV1alpha2().APIBindings().Get(ctx, g.APIBindingName, metav1.GetOptions{})
+		binding, err := apishelpers.GetAPIBinding(ctx, kcpClusterClient.Cluster(currentClusterName), preferredAPIBindingVersion, g.APIBindingName)
 		if err != nil {
-			return fmt.Errorf("error finding apibinding: %w", err)
+			return fmt.Errorf("error finding APIBinding: %w", err)
 		}
-		apibindings = append(apibindings, *binding)
+		bindingsList = apishelpers.NewAPIBindingList(binding)
 	}
 
-	for _, b := range apibindings {
-		for _, claim := range b.Spec.PermissionClaims {
-			err := printDetails(out, b.Name, claim.Group+"-"+claim.Resource, string(claim.State))
-			if err != nil {
-				allErrors = append(allErrors, err)
-			}
-		}
-	}
-
-	return utilerrors.NewAggregate(allErrors)
+	return bindingsList.PrintPermissionClaims(out)
 }
 
 func newKCPClusterClient(clientConfig clientcmd.ClientConfig) (kcpclientset.ClusterInterface, error) {
@@ -147,14 +139,3 @@ func newKCPClusterClient(clientConfig clientcmd.ClientConfig) (kcpclientset.Clus
 	clusterConfig.UserAgent = rest.DefaultKubernetesUserAgent()
 	return kcpclientset.NewForConfig(clusterConfig)
 }
-
-func printHeaders(out io.Writer) error {
-	columnNames := []string{"APIBINDING", "RESOURCE GROUP-VERSION", "STATUS"}
-	_, err := fmt.Fprintf(out, "%s\n", strings.Join(columnNames, "\t"))
-	return err
-}
-
-func printDetails(w io.Writer, name, binding, status string) error {
-	_, err := fmt.Fprintf(w, "%s\t%s\t%s\n", name, binding, status)
-	return err
-}

cli/pkg/helpers/apis/apis/apibinding.go

@@ -0,0 +1,87 @@
+/*
+Copyright 2025 The KCP Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package apis
+
+import (
+	"context"
+	"fmt"
+	"io"
+
+	apisv1alpha1 "github.com/kcp-dev/kcp/sdk/apis/apis/v1alpha1"
+	apisv1alpha2 "github.com/kcp-dev/kcp/sdk/apis/apis/v1alpha2"
+	kcpclientset "github.com/kcp-dev/kcp/sdk/client/clientset/versioned"
+)
+
+type APIBinding interface {
+	Name() string
+	Refresh(ctx context.Context, client kcpclientset.Interface) error
+	Create(ctx context.Context, client kcpclientset.Interface) error
+	SetPermissionClaims(claims []apisv1alpha2.AcceptablePermissionClaim) error
+	IsBound() bool
+}
+
+type APIBindingList interface {
+	PrintPermissionClaims(out io.Writer) error
+}
+
+func GetAPIBinding(ctx context.Context, client kcpclientset.Interface, preferredVersion string, name string) (APIBinding, error) {
+	switch preferredVersion {
+	case "v1alpha1":
+		return getAPIBindingV1alpha1(ctx, client, name)
+
+	case "v1alpha2":
+		return getAPIBindingV1alpha2(ctx, client, name)
+
+	default:
+		return nil, fmt.Errorf("version %q is not supported by this plugin", preferredVersion)
+	}
+}
+
+func ListAPIBindings(ctx context.Context, client kcpclientset.Interface, preferredVersion string) (APIBindingList, error) {
+	switch preferredVersion {
+	case "v1alpha1":
+		return listAPIBindingsV1alpha1(ctx, client)
+
+	case "v1alpha2":
+		return listAPIBindingsV1alpha2(ctx, client)
+
+	default:
+		return nil, fmt.Errorf("version %q is not supported by this plugin", preferredVersion)
+	}
+}
+
+func NewAPIBinding(nativeBinding any) APIBinding {
+	switch asserted := nativeBinding.(type) {
+	case *apisv1alpha1.APIBinding:
+		return &apiBindingV1alpha1{binding: asserted}
+	case *apisv1alpha2.APIBinding:
+		return &apiBindingV1alpha2{binding: asserted}
+	}
+
+	panic("Unsupported APIBinding version provided.")
+}
+
+func NewAPIBindingList(nativeBinding any) APIBindingList {
+	switch asserted := nativeBinding.(type) {
+	case *apisv1alpha1.APIBinding:
+		return &apiBindingListV1alpha1{bindings: []*apisv1alpha1.APIBinding{asserted}}
+	case *apisv1alpha2.APIBinding:
+		return &apiBindingListV1alpha2{bindings: []*apisv1alpha2.APIBinding{asserted}}
+	}
+
+	panic("Unsupported APIBinding version provided.")
+}