s/clusterPath/workspacePath/g due to popular demand

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

Author: xrstf

deploy/crd/kcp.io/syncagent.kcp.io_publishedresources.yaml

@@ -47,12 +47,12 @@ spec:
                 PublishedResourceSpec describes the desired resource publication from a service
                 cluster to kcp.
               properties:
-                enableClusterPaths:
+                enableWorkspacePaths:
                   description: |-
-                    EnableClusterPaths toggles whether the Sync Agent will not just store the kcp
-                    cluster name as a label on each locally synced object, but also the full cluster
+                    EnableWorkspacePaths toggles whether the Sync Agent will not just store the kcp
+                    cluster name as a label on each locally synced object, but also the full workspace
                     path. This is optional because it requires additional requests to kcp and
-                    should only be used if the cluster path is of interest on the
+                    should only be used if the workspace path is of interest on the
                     service cluster side.
                   type: boolean
                 filter:

internal/controller/sync/controller.go

@@ -162,14 +162,14 @@ func (r *Reconciler) Reconcile(ctx context.Context, request reconcile.Request) (
 
 	// if desired, fetch the cluster 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.EnableClusterPaths {
+	if r.pubRes.Spec.EnableWorkspacePaths {
 		lc := &kcpdevcorev1alpha1.LogicalCluster{}
 		if err := r.vwClient.Get(wsCtx, types.NamespacedName{Name: kcpdevcorev1alpha1.LogicalClusterName}, lc); err != nil {
 			return reconcile.Result{}, fmt.Errorf("failed to retrieve remote logicalcluster: %w", err)
 		}
 
 		path := lc.Annotations[kcpcore.LogicalClusterPathAnnotationKey]
-		syncContext = syncContext.WithClusterPath(logicalcluster.NewPath(path))
+		syncContext = syncContext.WithWorkspacePath(logicalcluster.NewPath(path))
 	}
 
 	// sync main object

internal/controller/syncmanager/lifecycle/cluster.go

@@ -103,18 +103,18 @@ func (c clusterRoundTripper) RoundTrip(req *http.Request) (*http.Response, error
 var apiRegex = regexp.MustCompile(`(/api/|/apis/)`)
 
 // generatePath formats the request path to target the specified cluster.
-func generatePath(originalPath string, clusterPath logicalcluster.Path) string {
+func generatePath(originalPath string, workspacePath logicalcluster.Path) string {
 	// If the originalPath already has cluster.Path() then the path was already modifed and no change needed
-	if strings.Contains(originalPath, clusterPath.RequestPath()) {
+	if strings.Contains(originalPath, workspacePath.RequestPath()) {
 		return originalPath
 	}
 	// If the originalPath has /api/ or /apis/ in it, it might be anywhere in the path, so we use a regex to find and
 	// replaces /api/ or /apis/ with $cluster/api/ or $cluster/apis/
 	if apiRegex.MatchString(originalPath) {
-		return apiRegex.ReplaceAllString(originalPath, fmt.Sprintf("%s$1", clusterPath.RequestPath()))
+		return apiRegex.ReplaceAllString(originalPath, fmt.Sprintf("%s$1", workspacePath.RequestPath()))
 	}
 	// Otherwise, we're just prepending /clusters/$name
-	path := clusterPath.RequestPath()
+	path := workspacePath.RequestPath()
 	// if the original path is relative, add a / separator
 	if len(originalPath) > 0 && originalPath[0] != '/' {
 		path += "/"

internal/sync/context.go

@@ -25,10 +25,10 @@ import (
 )
 
 type Context struct {
-	clusterName logicalcluster.Name
-	clusterPath logicalcluster.Path
-	local       context.Context
-	remote      context.Context
+	clusterName   logicalcluster.Name
+	workspacePath logicalcluster.Path
+	local         context.Context
+	remote        context.Context
 }
 
 func NewContext(local, remote context.Context) Context {
@@ -44,11 +44,11 @@ func NewContext(local, remote context.Context) Context {
 	}
 }
 
-func (c *Context) WithClusterPath(path logicalcluster.Path) Context {
+func (c *Context) WithWorkspacePath(path logicalcluster.Path) Context {
 	return Context{
-		clusterName: c.clusterName,
-		clusterPath: path,
-		local:       c.local,
-		remote:      c.remote,
+		clusterName:   c.clusterName,
+		workspacePath: path,
+		local:         c.local,
+		remote:        c.remote,
 	}
 }

internal/sync/meta.go

@@ -94,18 +94,18 @@ func removeFinalizer(ctx context.Context, log *zap.SugaredLogger, client ctrlrun
 }
 
 type objectKey struct {
-	ClusterName logicalcluster.Name
-	ClusterPath logicalcluster.Path
-	Namespace   string
-	Name        string
+	ClusterName   logicalcluster.Name
+	WorkspacePath logicalcluster.Path
+	Namespace     string
+	Name          string
 }
 
-func newObjectKey(obj metav1.Object, clusterName logicalcluster.Name, clusterPath logicalcluster.Path) objectKey {
+func newObjectKey(obj metav1.Object, clusterName logicalcluster.Name, workspacePath logicalcluster.Path) objectKey {
 	return objectKey{
-		ClusterName: clusterName,
-		ClusterPath: clusterPath,
-		Namespace:   obj.GetNamespace(),
-		Name:        obj.GetName(),
+		ClusterName:   clusterName,
+		WorkspacePath: workspacePath,
+		Namespace:     obj.GetNamespace(),
+		Name:          obj.GetName(),
 	}
 }
 
@@ -144,8 +144,8 @@ func (k objectKey) Labels() labels.Set {
 func (k objectKey) Annotations() labels.Set {
 	s := labels.Set{}
 
-	if !k.ClusterPath.Empty() {
-		s[remoteObjectClusterPathAnnotation] = k.ClusterPath.String()
+	if !k.WorkspacePath.Empty() {
+		s[remoteObjectWorkspacePathAnnotation] = k.WorkspacePath.String()
 	}
 
 	return s

internal/sync/meta_test.go

@@ -35,10 +35,10 @@ func createNewObject(name, namespace string) metav1.Object {
 
 func TestObjectKey(t *testing.T) {
 	testcases := []struct {
-		object      metav1.Object
-		clusterName logicalcluster.Name
-		clusterPath logicalcluster.Path
-		expected    string
+		object        metav1.Object
+		clusterName   logicalcluster.Name
+		workspacePath logicalcluster.Path
+		expected      string
 	}{
 		{
 			object:      createNewObject("test", ""),
@@ -61,16 +61,16 @@ func TestObjectKey(t *testing.T) {
 			expected:    "abc123|namespace/test",
 		},
 		{
-			object:      createNewObject("test", "namespace"),
-			clusterName: "abc123",
-			clusterPath: logicalcluster.NewPath("this:should:not:appear:in:the:key"),
-			expected:    "abc123|namespace/test",
+			object:        createNewObject("test", "namespace"),
+			clusterName:   "abc123",
+			workspacePath: logicalcluster.NewPath("this:should:not:appear:in:the:key"),
+			expected:      "abc123|namespace/test",
 		},
 	}
 
 	for _, testcase := range testcases {
 		t.Run("", func(t *testing.T) {
-			key := newObjectKey(testcase.object, testcase.clusterName, testcase.clusterPath)
+			key := newObjectKey(testcase.object, testcase.clusterName, testcase.workspacePath)
 
 			if stringified := key.String(); stringified != testcase.expected {
 				t.Fatalf("Expected %q but got %q.", testcase.expected, stringified)

internal/sync/object_syncer.go

@@ -54,11 +54,11 @@ type objectSyncer struct {
 }
 
 type syncSide struct {
-	ctx         context.Context
-	clusterName logicalcluster.Name
-	clusterPath logicalcluster.Path
-	client      ctrlruntimeclient.Client
-	object      *unstructured.Unstructured
+	ctx           context.Context
+	clusterName   logicalcluster.Name
+	workspacePath logicalcluster.Path
+	client        ctrlruntimeclient.Client
+	object        *unstructured.Unstructured
 }
 
 func (s *objectSyncer) Sync(log *zap.SugaredLogger, source, dest syncSide) (requeue bool, err error) {
@@ -183,9 +183,9 @@ func (s *objectSyncer) syncObjectSpec(log *zap.SugaredLogger, source, dest syncS
 		lastKnownSourceState.SetAPIVersion(sourceObjCopy.GetAPIVersion())
 		lastKnownSourceState.SetKind(sourceObjCopy.GetKind())
 
-		// update annotations (this is important if the admin later flipped the enableClusterPaths
+		// update annotations (this is important if the admin later flipped the enableWorkspacePaths
 		// option in the PublishedResource)
-		sourceKey := newObjectKey(source.object, source.clusterName, source.clusterPath)
+		sourceKey := newObjectKey(source.object, source.clusterName, source.workspacePath)
 		ensureAnnotations(sourceObjCopy, sourceKey.Annotations())
 
 		// now we can diff the two versions and create a patch
@@ -278,7 +278,7 @@ func (s *objectSyncer) ensureDestinationObject(log *zap.SugaredLogger, source, d
 	stripMetadata(destObj)
 
 	// remember the connection between the source and destination object
-	sourceObjKey := newObjectKey(source.object, source.clusterName, source.clusterPath)
+	sourceObjKey := newObjectKey(source.object, source.clusterName, source.workspacePath)
 	ensureLabels(destObj, sourceObjKey.Labels())
 
 	// put optional additional annotations on the new object

internal/sync/state_store.go

@@ -133,7 +133,7 @@ func hashObject(obj *unstructured.Unstructured) string {
 func newKubernetesBackend(namespace string, primaryObject, stateCluster syncSide) *kubernetesBackend {
 	keyHash := hashObject(primaryObject.object)
 
-	secretLabels := newObjectKey(primaryObject.object, primaryObject.clusterName, primaryObject.clusterPath).Labels()
+	secretLabels := newObjectKey(primaryObject.object, primaryObject.clusterName, primaryObject.workspacePath).Labels()
 	secretLabels[objectStateLabelName] = objectStateLabelValue
 
 	return &kubernetesBackend{

internal/sync/syncer.go

@@ -112,7 +112,7 @@ func NewResourceSyncer(
 // case, the caller should re-fetch the remote object and call Process() again (most likely in the
 // next reconciliation). Only when (false, nil) is returned is the entire process finished.
 func (s *ResourceSyncer) Process(ctx Context, remoteObj *unstructured.Unstructured) (requeue bool, err error) {
-	log := s.log.With("source-object", newObjectKey(remoteObj, ctx.clusterName, ctx.clusterPath))
+	log := s.log.With("source-object", newObjectKey(remoteObj, ctx.clusterName, ctx.workspacePath))
 
 	// find the local equivalent object in the local service cluster
 	localObj, err := s.findLocalObject(ctx, remoteObj)
@@ -126,11 +126,11 @@ func (s *ResourceSyncer) Process(ctx Context, remoteObj *unstructured.Unstructur
 	// Prepare object sync sides.
 
 	sourceSide := syncSide{
-		ctx:         ctx.remote,
-		clusterName: ctx.clusterName,
-		clusterPath: ctx.clusterPath,
-		client:      s.remoteClient,
-		object:      remoteObj,
+		ctx:           ctx.remote,
+		clusterName:   ctx.clusterName,
+		workspacePath: ctx.workspacePath,
+		client:        s.remoteClient,
+		object:        remoteObj,
 	}
 
 	destSide := syncSide{
@@ -182,7 +182,7 @@ func (s *ResourceSyncer) Process(ctx Context, remoteObj *unstructured.Unstructur
 }
 
 func (s *ResourceSyncer) findLocalObject(ctx Context, remoteObj *unstructured.Unstructured) (*unstructured.Unstructured, error) {
-	localSelector := labels.SelectorFromSet(newObjectKey(remoteObj, ctx.clusterName, ctx.clusterPath).Labels())
+	localSelector := labels.SelectorFromSet(newObjectKey(remoteObj, ctx.clusterName, ctx.workspacePath).Labels())
 
 	localObjects := &unstructured.UnstructuredList{}
 	localObjects.SetAPIVersion(s.destDummy.GetAPIVersion())

internal/sync/types.go

@@ -29,7 +29,7 @@ const (
 	remoteObjectNamespaceLabel = "syncagent.kcp.io/remote-object-namespace"
 	remoteObjectNameLabel      = "syncagent.kcp.io/remote-object-name"
 
-	remoteObjectClusterPathAnnotation = "syncagent.kcp.io/remote-object-cluster-path"
+	remoteObjectWorkspacePathAnnotation = "syncagent.kcp.io/remote-object-workspace-path"
 
 	// objectStateLabelName is put on object state Secrets to allow for easier mass deletions
 	// if ever necessary.