improve import aliases and grouping

On-behalf-of: @SAP [email protected]

Author: xrstf

.gimps.yaml

@@ -21,12 +21,14 @@ sets:
       - 'k8s.io/**'
       - 'sigs.k8s.io/controller-runtime/**'
       - 'sigs.k8s.io/controller-tools/**'
+      - 'sigs.k8s.io/multicluster-runtime/**'
       - 'sigs.k8s.io/yaml/**'
       - 'github.com/kcp-dev/client-go/**'
       - 'github.com/kcp-dev/kubernetes/**'
   - name: kcp
     patterns:
       - 'github.com/kcp-dev/kcp/**'
-      - 'github.com/kcp-dev/multicluster-provider/**'
+      - 'github.com/kcp-dev/sdk/**'
+      - 'github.com/kcp-dev/logicalcluster/**'
       - 'github.com/kcp-dev/code-generator/**'
-      - 'sigs.k8s.io/multicluster-runtime/**'
+      - 'github.com/kcp-dev/multicluster-provider/**'

.golangci.yml

@@ -74,6 +74,9 @@ linters:
         # Controller Runtime
         - pkg: sigs.k8s.io/controller-runtime/pkg/client
           alias: ctrlruntimeclient
+        # kcp APIs
+        - pkg: github.com/kcp-dev/sdk/apis/(\w+)/(v[\w\d]+)
+          alias: kcp$1$2
       no-unaliased: true
   exclusions:
     generated: lax

cmd/api-syncagent/kcp.go

@@ -22,13 +22,12 @@ import (
 	"fmt"
 	"regexp"
 
-	"github.com/kcp-dev/logicalcluster/v3"
-
 	"github.com/kcp-dev/api-syncagent/internal/kcp"
 
-	kcpdevv1alpha1 "github.com/kcp-dev/sdk/apis/apis/v1alpha1"
-	kcpdevcore "github.com/kcp-dev/sdk/apis/core"
-	kcpdevcorev1alpha1 "github.com/kcp-dev/sdk/apis/core/v1alpha1"
+	"github.com/kcp-dev/logicalcluster/v3"
+	kcpapisv1alpha1 "github.com/kcp-dev/sdk/apis/apis/v1alpha1"
+	kcpcore "github.com/kcp-dev/sdk/apis/core"
+	kcpcorev1alpha1 "github.com/kcp-dev/sdk/apis/core/v1alpha1"
 
 	"k8s.io/apimachinery/pkg/fields"
 	"k8s.io/apimachinery/pkg/runtime"
@@ -60,18 +59,18 @@ func setupEndpointKcpCluster(endpoint *syncEndpoint) (cluster.Cluster, error) {
 
 	scheme := runtime.NewScheme()
 
-	if err := kcpdevv1alpha1.AddToScheme(scheme); err != nil {
-		return nil, fmt.Errorf("failed to register scheme %s: %w", kcpdevv1alpha1.SchemeGroupVersion, err)
+	if err := kcpapisv1alpha1.AddToScheme(scheme); err != nil {
+		return nil, fmt.Errorf("failed to register scheme %s: %w", kcpapisv1alpha1.SchemeGroupVersion, err)
 	}
 
-	if err := kcpdevcorev1alpha1.AddToScheme(scheme); err != nil {
-		return nil, fmt.Errorf("failed to register scheme %s: %w", kcpdevcorev1alpha1.SchemeGroupVersion, err)
+	if err := kcpcorev1alpha1.AddToScheme(scheme); err != nil {
+		return nil, fmt.Errorf("failed to register scheme %s: %w", kcpcorev1alpha1.SchemeGroupVersion, err)
 	}
 
 	// RBAC in kcp might be very tight and might not allow to list/watch all objects;
 	// restrict the cache's selectors accordingly so we can still make use of caching.
 	byObject := map[ctrlruntimeclient.Object]cache.ByObject{
-		&kcpdevv1alpha1.APIExportEndpointSlice{}: {
+		&kcpapisv1alpha1.APIExportEndpointSlice{}: {
 			Field: fields.SelectorFromSet(fields.Set{"metadata.name": endpoint.EndpointSlice.Name}),
 		},
 	}
@@ -90,18 +89,18 @@ func setupEndpointKcpCluster(endpoint *syncEndpoint) (cluster.Cluster, error) {
 func setupManagedKcpCluster(endpoint *syncEndpoint) (cluster.Cluster, error) {
 	scheme := runtime.NewScheme()
 
-	if err := kcpdevv1alpha1.AddToScheme(scheme); err != nil {
-		return nil, fmt.Errorf("failed to register scheme %s: %w", kcpdevv1alpha1.SchemeGroupVersion, err)
+	if err := kcpapisv1alpha1.AddToScheme(scheme); err != nil {
+		return nil, fmt.Errorf("failed to register scheme %s: %w", kcpapisv1alpha1.SchemeGroupVersion, err)
 	}
 
-	if err := kcpdevcorev1alpha1.AddToScheme(scheme); err != nil {
-		return nil, fmt.Errorf("failed to register scheme %s: %w", kcpdevcorev1alpha1.SchemeGroupVersion, err)
+	if err := kcpcorev1alpha1.AddToScheme(scheme); err != nil {
+		return nil, fmt.Errorf("failed to register scheme %s: %w", kcpcorev1alpha1.SchemeGroupVersion, err)
 	}
 
 	// RBAC in kcp might be very tight and might not allow to list/watch all objects;
 	// restrict the cache's selectors accordingly so we can still make use of caching.
 	byObject := map[ctrlruntimeclient.Object]cache.ByObject{
-		&kcpdevv1alpha1.APIExport{}: {
+		&kcpapisv1alpha1.APIExport{}: {
 			Field: fields.SelectorFromSet(fields.Set{"metadata.name": endpoint.APIExport.Name}),
 		},
 	}
@@ -145,11 +144,11 @@ type syncEndpoint struct {
 func resolveSyncEndpoint(ctx context.Context, initialRestConfig *rest.Config, endpointSliceRef string, apiExportRef string) (*syncEndpoint, error) {
 	// construct temporary, uncached client
 	scheme := runtime.NewScheme()
-	if err := kcpdevcorev1alpha1.AddToScheme(scheme); err != nil {
-		return nil, fmt.Errorf("failed to register scheme %s: %w", kcpdevcorev1alpha1.SchemeGroupVersion, err)
+	if err := kcpcorev1alpha1.AddToScheme(scheme); err != nil {
+		return nil, fmt.Errorf("failed to register scheme %s: %w", kcpcorev1alpha1.SchemeGroupVersion, err)
 	}
-	if err := kcpdevv1alpha1.AddToScheme(scheme); err != nil {
-		return nil, fmt.Errorf("failed to register scheme %s: %w", kcpdevv1alpha1.SchemeGroupVersion, err)
+	if err := kcpapisv1alpha1.AddToScheme(scheme); err != nil {
+		return nil, fmt.Errorf("failed to register scheme %s: %w", kcpapisv1alpha1.SchemeGroupVersion, err)
 	}
 
 	clientOpts := ctrlruntimeclient.Options{Scheme: scheme}
@@ -160,58 +159,38 @@ func resolveSyncEndpoint(ctx context.Context, initialRestConfig *rest.Config, en
 
 	se := &syncEndpoint{}
 
-	// When an endpoint ref is given, both the APIExportEndpointSlice and the APIExport must exist.
-	if endpointSliceRef != "" {
-		endpointSlice, err := resolveAPIExportEndpointSlice(ctx, client, endpointSliceRef)
-		if err != nil {
-			return nil, fmt.Errorf("failed to resolve APIExportEndpointSlice: %w", err)
-		}
-		endpointSlice.Config = initialRestConfig
-
-		// find the APIExport referenced not by the user (can't: both ref parameters to this function
-		// are mutually exclusive), but in the APIExportEndpointSlice.
-		restConfig, err := retargetRestConfig(initialRestConfig, endpointSlice.Spec.APIExport.Path)
-		if err != nil {
-			return nil, fmt.Errorf("failed to re-target the given kubeconfig to cluster %q: %w", endpointSlice.Spec.APIExport.Path, err)
-		}
-
-		client, err := ctrlruntimeclient.New(restConfig, clientOpts)
-		if err != nil {
-			return nil, fmt.Errorf("failed to create service reader: %w", err)
-		}
+	// First we find the APIExportEndpointSlice.
+	endpointSlice, err := resolveAPIExportEndpointSlice(ctx, client, endpointSliceRef)
+	if err != nil {
+		return nil, fmt.Errorf("failed to resolve APIExportEndpointSlice: %w", err)
+	}
+	endpointSlice.Config = initialRestConfig
 
-		apiExport, err := resolveAPIExport(ctx, client, endpointSlice.Spec.APIExport.Name)
-		if err != nil {
-			return nil, fmt.Errorf("failed to resolve APIExport: %w", err)
-		}
-		apiExport.Config = restConfig
-
-		se.APIExport = apiExport
-		se.EndpointSlice = &endpointSlice
-	} else { // if an export ref is given, the endpoint slice is optional (for compat with kcp <0.28)
-		apiExport, err := resolveAPIExport(ctx, client, apiExportRef)
-		if err != nil {
-			return nil, fmt.Errorf("failed to resolve APIExport: %w", err)
-		}
-		apiExport.Config = initialRestConfig
+	// Now we find the APIExport referenced in the APIExportEndpointSlice.
+	restConfig, err := retargetRestConfig(initialRestConfig, endpointSlice.Spec.APIExport.Path)
+	if err != nil {
+		return nil, fmt.Errorf("failed to re-target the given kubeconfig to cluster %q: %w", endpointSlice.Spec.APIExport.Path, err)
+	}
 
-		se.APIExport = apiExport
+	client, err = ctrlruntimeclient.New(restConfig, clientOpts)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create service reader: %w", err)
+	}
 
-		// try to find an endpoint slice in the same workspace with the same name as the APIExport
-		endpointSlice, err := resolveAPIExportEndpointSlice(ctx, client, apiExportRef)
-		if ctrlruntimeclient.IgnoreNotFound(err) != nil {
-			return nil, fmt.Errorf("failed to resolve APIExportEndpointSlice: %w", err)
-		} else if err == nil {
-			apiExport.Config = initialRestConfig
-			se.EndpointSlice = &endpointSlice
-		}
+	apiExport, err := resolveAPIExport(ctx, client, endpointSlice.Spec.APIExport.Name)
+	if err != nil {
+		return nil, fmt.Errorf("failed to resolve APIExport: %w", err)
 	}
+	apiExport.Config = restConfig
+
+	se.APIExport = apiExport
+	se.EndpointSlice = endpointSlice
 
 	return se, nil
 }
 
 func resolveAPIExportEndpointSlice(ctx context.Context, client ctrlruntimeclient.Client, ref string) (qualifiedAPIExportEndpointSlice, error) {
-	endpointSlice := &kcpdevv1alpha1.APIExportEndpointSlice{}
+	endpointSlice := &kcpapisv1alpha1.APIExportEndpointSlice{}
 	key := types.NamespacedName{Name: ref}
 	if err := client.Get(ctx, key, endpointSlice); err != nil {
 		return qualifiedAPIExportEndpointSlice{}, fmt.Errorf("failed to get APIExportEndpointSlice %q: %w", ref, err)
@@ -232,7 +211,7 @@ func resolveAPIExportEndpointSlice(ctx context.Context, client ctrlruntimeclient
 }
 
 func resolveAPIExport(ctx context.Context, client ctrlruntimeclient.Client, ref string) (qualifiedAPIExport, error) {
-	apiExport := &kcpdevv1alpha1.APIExport{}
+	apiExport := &kcpapisv1alpha1.APIExport{}
 	key := types.NamespacedName{Name: ref}
 	if err := client.Get(ctx, key, apiExport); err != nil {
 		return qualifiedAPIExport{}, fmt.Errorf("failed to get APIExport %q: %w", ref, err)
@@ -253,13 +232,13 @@ func resolveAPIExport(ctx context.Context, client ctrlruntimeclient.Client, ref
 }
 
 func resolveCurrentCluster(ctx context.Context, client ctrlruntimeclient.Client) (logicalcluster.Name, logicalcluster.Path, error) {
-	lc := &kcpdevcorev1alpha1.LogicalCluster{}
+	lc := &kcpcorev1alpha1.LogicalCluster{}
 	if err := client.Get(ctx, types.NamespacedName{Name: kcp.IdentityClusterName}, lc); err != nil {
 		return "", logicalcluster.None, fmt.Errorf("failed to resolve current workspace: %w", err)
 	}
 
 	lcName := logicalcluster.From(lc)
-	lcPath := logicalcluster.NewPath(lc.Annotations[kcpdevcore.LogicalClusterPathAnnotationKey])
+	lcPath := logicalcluster.NewPath(lc.Annotations[kcpcore.LogicalClusterPathAnnotationKey])
 
 	return lcName, lcPath, nil
 }

cmd/api-syncagent/main.go

@@ -36,7 +36,7 @@ import (
 	"github.com/kcp-dev/api-syncagent/internal/version"
 	syncagentv1alpha1 "github.com/kcp-dev/api-syncagent/sdk/apis/syncagent/v1alpha1"
 
-	kcpdevv1alpha1 "github.com/kcp-dev/sdk/apis/apis/v1alpha1"
+	kcpapisv1alpha1 "github.com/kcp-dev/sdk/apis/apis/v1alpha1"
 
 	corev1 "k8s.io/api/core/v1"
 	apiextensionsv1 "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1"

internal/controller/apiexport/controller.go

@@ -20,7 +20,6 @@ import (
 	"context"
 	"fmt"
 
-	"github.com/kcp-dev/logicalcluster/v3"
 	"go.uber.org/zap"
 
 	"github.com/kcp-dev/api-syncagent/internal/controllerutil"
@@ -31,7 +30,8 @@ import (
 	"github.com/kcp-dev/api-syncagent/internal/resources/reconciling"
 	syncagentv1alpha1 "github.com/kcp-dev/api-syncagent/sdk/apis/syncagent/v1alpha1"
 
-	kcpdevv1alpha1 "github.com/kcp-dev/sdk/apis/apis/v1alpha1"
+	"github.com/kcp-dev/logicalcluster/v3"
+	kcpapisv1alpha1 "github.com/kcp-dev/sdk/apis/apis/v1alpha1"
 
 	"k8s.io/apimachinery/pkg/labels"
 	"k8s.io/apimachinery/pkg/runtime/schema"
@@ -109,7 +109,7 @@ func Add(
 		// Watch for changes to APIExport on the kcp side to start/restart the actual syncing controllers;
 		// the cache is already restricted by a fieldSelector in the main.go to respect the RBC restrictions,
 		// so there is no need here to add an additional filter.
-		WatchesRawSource(source.Kind(kcpCluster.GetCache(), &kcpdevv1alpha1.APIExport{}, controllerutil.EnqueueConst[*kcpdevv1alpha1.APIExport]("dummy"))).
+		WatchesRawSource(source.Kind(kcpCluster.GetCache(), &kcpapisv1alpha1.APIExport{}, controllerutil.EnqueueConst[*kcpapisv1alpha1.APIExport]("dummy"))).
 		// Watch for changes to PublishedResources on the local service cluster
 		Watches(&syncagentv1alpha1.PublishedResource{}, controllerutil.EnqueueConst[ctrlruntimeclient.Object]("dummy"), builder.WithPredicates(predicateutil.ByLabels(prFilter), hasARS)).
 		Build(reconciler)
@@ -120,15 +120,15 @@ func Add(
 func (r *Reconciler) Reconcile(ctx context.Context, request reconcile.Request) (reconcile.Result, error) {
 	r.log.Debug("Processing")
 
-	apiExport := &kcpdevv1alpha1.APIExport{}
+	apiExport := &kcpapisv1alpha1.APIExport{}
 	if err := r.kcpClient.Get(ctx, types.NamespacedName{Name: r.apiExportName}, apiExport); err != nil {
 		return reconcile.Result{}, ctrlruntimeclient.IgnoreNotFound(err)
 	}
 
 	return reconcile.Result{}, r.reconcile(ctx, apiExport)
 }
 
-func (r *Reconciler) reconcile(ctx context.Context, apiExport *kcpdevv1alpha1.APIExport) error {
+func (r *Reconciler) reconcile(ctx context.Context, apiExport *kcpapisv1alpha1.APIExport) error {
 	// find all PublishedResources; we keep those that are not yet converted into ARS,
 	// just to reduce the amount of re-reconciles when the agent processes a number of PRs in a row
 	// and would constantly update the APIExport; instead we rely on kcp to handle the eventual

internal/controller/apiexport/reconciler.go

@@ -24,7 +24,7 @@ import (
 	"github.com/kcp-dev/api-syncagent/internal/resources/reconciling"
 	syncagentv1alpha1 "github.com/kcp-dev/api-syncagent/sdk/apis/syncagent/v1alpha1"
 
-	kcpdevv1alpha1 "github.com/kcp-dev/sdk/apis/apis/v1alpha1"
+	kcpapisv1alpha1 "github.com/kcp-dev/sdk/apis/apis/v1alpha1"
 
 	corev1 "k8s.io/api/core/v1"
 	"k8s.io/apimachinery/pkg/runtime"
@@ -61,7 +61,7 @@ func (r *Reconciler) createAPIExportReconciler(
 	recorder record.EventRecorder,
 ) reconciling.NamedAPIExportReconcilerFactory {
 	return func() (string, reconciling.APIExportReconciler) {
-		return apiExportName, func(existing *kcpdevv1alpha1.APIExport) (*kcpdevv1alpha1.APIExport, error) {
+		return apiExportName, func(existing *kcpapisv1alpha1.APIExport) (*kcpapisv1alpha1.APIExport, error) {
 			if existing.Annotations == nil {
 				existing.Annotations = map[string]string{}
 			}
@@ -102,8 +102,8 @@ func (r *Reconciler) createAPIExportReconciler(
 
 			// add our missing claims
 			for _, claimed := range claimsToAdd {
-				existing.Spec.PermissionClaims = append(existing.Spec.PermissionClaims, kcpdevv1alpha1.PermissionClaim{
-					GroupResource: kcpdevv1alpha1.GroupResource{
+				existing.Spec.PermissionClaims = append(existing.Spec.PermissionClaims, kcpapisv1alpha1.PermissionClaim{
+					GroupResource: kcpapisv1alpha1.GroupResource{
 						Group:    claimed.Group,
 						Resource: claimed.Resource,
 					},
@@ -121,7 +121,7 @@ func (r *Reconciler) createAPIExportReconciler(
 			}
 
 			// prevent reconcile loops by ensuring a stable order
-			slices.SortFunc(existing.Spec.PermissionClaims, func(a, b kcpdevv1alpha1.PermissionClaim) int {
+			slices.SortFunc(existing.Spec.PermissionClaims, func(a, b kcpapisv1alpha1.PermissionClaim) int {
 				if a.Group != b.Group {
 					return strings.Compare(a.Group, b.Group)
 				}

internal/controller/apiresourceschema/controller.go

@@ -21,7 +21,6 @@ import (
 	"fmt"
 	"reflect"
 
-	"github.com/kcp-dev/logicalcluster/v3"
 	"go.uber.org/zap"
 
 	"github.com/kcp-dev/api-syncagent/internal/controllerutil/predicate"
@@ -30,7 +29,8 @@ import (
 	"github.com/kcp-dev/api-syncagent/internal/projection"
 	syncagentv1alpha1 "github.com/kcp-dev/api-syncagent/sdk/apis/syncagent/v1alpha1"
 
-	kcpdevv1alpha1 "github.com/kcp-dev/sdk/apis/apis/v1alpha1"
+	"github.com/kcp-dev/logicalcluster/v3"
+	kcpapisv1alpha1 "github.com/kcp-dev/sdk/apis/apis/v1alpha1"
 
 	corev1 "k8s.io/api/core/v1"
 	apiextensionsv1 "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1"
@@ -159,7 +159,7 @@ func (r *Reconciler) reconcile(ctx context.Context, log *zap.SugaredLogger, pubR
 	arsName := kcp.GetAPIResourceSchemaName(projectedCRD)
 
 	// ensure ARS exists (don't try to reconcile it, it's basically entirely immutable)
-	ars := &kcpdevv1alpha1.APIResourceSchema{}
+	ars := &kcpapisv1alpha1.APIResourceSchema{}
 	err = r.kcpClient.Get(ctx, types.NamespacedName{Name: arsName}, ars, &ctrlruntimeclient.GetOptions{})
 
 	if apierrors.IsNotFound(err) {

internal/controller/sync/controller.go

@@ -22,7 +22,6 @@ import (
 	"time"
 
 	"github.com/go-logr/zapr"
-	"github.com/kcp-dev/logicalcluster/v3"
 	"go.uber.org/zap"
 
 	"github.com/kcp-dev/api-syncagent/internal/discovery"
@@ -31,13 +30,9 @@ import (
 	"github.com/kcp-dev/api-syncagent/internal/sync"
 	syncagentv1alpha1 "github.com/kcp-dev/api-syncagent/sdk/apis/syncagent/v1alpha1"
 
+	"github.com/kcp-dev/logicalcluster/v3"
 	kcpcore "github.com/kcp-dev/sdk/apis/core"
-	kcpdevcorev1alpha1 "github.com/kcp-dev/sdk/apis/core/v1alpha1"
-	mccontroller "sigs.k8s.io/multicluster-runtime/pkg/controller"
-	mchandler "sigs.k8s.io/multicluster-runtime/pkg/handler"
-	mcmanager "sigs.k8s.io/multicluster-runtime/pkg/manager"
-	mcreconcile "sigs.k8s.io/multicluster-runtime/pkg/reconcile"
-	mcsource "sigs.k8s.io/multicluster-runtime/pkg/source"
+	kcpcorev1alpha1 "github.com/kcp-dev/sdk/apis/core/v1alpha1"
 
 	corev1 "k8s.io/api/core/v1"
 	apiextensionsv1 "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1"
@@ -52,6 +47,11 @@ import (
 	"sigs.k8s.io/controller-runtime/pkg/predicate"
 	"sigs.k8s.io/controller-runtime/pkg/reconcile"
 	"sigs.k8s.io/controller-runtime/pkg/source"
+	mccontroller "sigs.k8s.io/multicluster-runtime/pkg/controller"
+	mchandler "sigs.k8s.io/multicluster-runtime/pkg/handler"
+	mcmanager "sigs.k8s.io/multicluster-runtime/pkg/manager"
+	mcreconcile "sigs.k8s.io/multicluster-runtime/pkg/reconcile"
+	mcsource "sigs.k8s.io/multicluster-runtime/pkg/source"
 )
 
 const (
@@ -215,8 +215,8 @@ func (r *Reconciler) Reconcile(ctx context.Context, request mcreconcile.Request)
 	// if desired, fetch the workspace path as well (some downstream service providers might make use of it,
 	// but since it requires an additional permission claim, it's optional)
 	if r.pubRes.Spec.EnableWorkspacePaths {
-		lc := &kcpdevcorev1alpha1.LogicalCluster{}
-		if err := vwClient.Get(ctx, types.NamespacedName{Name: kcpdevcorev1alpha1.LogicalClusterName}, lc); err != nil {
+		lc := &kcpcorev1alpha1.LogicalCluster{}
+		if err := vwClient.Get(ctx, types.NamespacedName{Name: kcpcorev1alpha1.LogicalClusterName}, lc); err != nil {
 			recorder.Event(remoteObj, corev1.EventTypeWarning, "ReconcilingError", "Failed to retrieve workspace path, cannot process object.")
 			return reconcile.Result{}, fmt.Errorf("failed to retrieve remote logicalcluster: %w", err)
 		}