Merge pull request #1577 from openshift-cherrypick-robot/cherry-pick-1566-to-release-0.6

[release-0.6] syncer/namespace-locator: Rename path to workspace

Author: openshift-merge-robot

pkg/syncer/shared/namespace.go

@@ -41,17 +41,30 @@ type NamespaceLocator struct {
 }
 
 type SyncTargetLocator struct {
-	Path logicalcluster.Name `json:"path"`
-	Name string              `json:"name"`
-	UID  types.UID           `json:"uid"`
+	Workspace      string    `json:"workspace,omitempty"`
+	DeprecatedPath string    `json:"path,omitempty"`
+	Name           string    `json:"name"`
+	UID            types.UID `json:"uid"`
 }
 
 func NewNamespaceLocator(workspace, syncTargetWorkspace logicalcluster.Name, syncTargetUID types.UID, workloadLogicalClusterName, upstreamNamespace string) NamespaceLocator {
 	return NamespaceLocator{
 		SyncTarget: SyncTargetLocator{
-			Path: syncTargetWorkspace,
-			Name: workloadLogicalClusterName,
-			UID:  syncTargetUID,
+			Workspace: syncTargetWorkspace.String(),
+			Name:      workloadLogicalClusterName,
+			UID:       syncTargetUID,
+		},
+		Workspace: workspace,
+		Namespace: upstreamNamespace,
+	}
+}
+
+func NewNamespaceLocatorV060(workspace, syncTargetWorkspace logicalcluster.Name, syncTargetUID types.UID, workloadLogicalClusterName, upstreamNamespace string) NamespaceLocator {
+	return NamespaceLocator{
+		SyncTarget: SyncTargetLocator{
+			DeprecatedPath: syncTargetWorkspace.String(),
+			Name:           workloadLogicalClusterName,
+			UID:            syncTargetUID,
 		},
 		Workspace: workspace,
 		Namespace: upstreamNamespace,
@@ -67,6 +80,13 @@ func LocatorFromAnnotations(annotations map[string]string) (*NamespaceLocator, b
 	if err := json.Unmarshal([]byte(annotation), &locator); err != nil {
 		return nil, false, err
 	}
+
+	// get us from v0.6.0 locators (using syncTarget.path) to v0.6.1+ (using syncTarget.workspace)
+	if locator.SyncTarget.Workspace == "" {
+		locator.SyncTarget.Workspace = locator.SyncTarget.DeprecatedPath
+	}
+	locator.SyncTarget.DeprecatedPath = ""
+
 	return &locator, true, nil
 }
 

pkg/syncer/shared/namespace_test.go

@@ -0,0 +1,101 @@
+/*
+Copyright 2022 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 shared
+
+import (
+	"reflect"
+	"strings"
+	"testing"
+
+	"github.com/kcp-dev/logicalcluster"
+)
+
+func TestLocatorFromAnnotations(t *testing.T) {
+	tests := []struct {
+		name        string
+		annotations map[string]string
+		want        *NamespaceLocator
+		wantFound   bool
+		wantErrs    []string
+	}{
+		{
+			name:      "no annotation",
+			wantFound: false,
+		},
+		{
+			name: "garbage",
+			annotations: map[string]string{
+				NamespaceLocatorAnnotation: "garbage",
+			},
+			wantErrs: []string{"invalid character"},
+		},
+		{
+			name: "happy case",
+			annotations: map[string]string{
+				NamespaceLocatorAnnotation: `{"syncTarget":{"workspace":"test-workspace","name":"test-name","uid":"test-uid"},"workspace":"test-workspace","namespace":"test-namespace"}`,
+			},
+			want: &NamespaceLocator{
+				SyncTarget: SyncTargetLocator{
+					Workspace: "test-workspace",
+					Name:      "test-name",
+					UID:       "test-uid",
+				},
+				Workspace: logicalcluster.New("test-workspace"),
+				Namespace: "test-namespace",
+			},
+			wantFound: true,
+		},
+		{
+			name: "format up to v0.6.0",
+			annotations: map[string]string{
+				NamespaceLocatorAnnotation: `{"syncTarget":{"path":"test-workspace","name":"test-name","uid":"test-uid"},"workspace":"test-workspace","namespace":"test-namespace"}`,
+			},
+			want: &NamespaceLocator{
+				SyncTarget: SyncTargetLocator{
+					Workspace: "test-workspace",
+					Name:      "test-name",
+					UID:       "test-uid",
+				},
+				Workspace: logicalcluster.New("test-workspace"),
+				Namespace: "test-namespace",
+			},
+			wantFound: true,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, gotFound, err := LocatorFromAnnotations(tt.annotations)
+			if (err != nil) != (len(tt.wantErrs) > 0) {
+				t.Errorf("LocatorFromAnnotations() error = %q, wantErrs %v", err.Error(), tt.wantErrs)
+				return
+			} else if err != nil {
+				for _, wantErr := range tt.wantErrs {
+					if !strings.Contains(err.Error(), wantErr) {
+						t.Errorf("LocatorFromAnnotations() error = %q, wantErrs %q", err.Error(), wantErr)
+						return
+					}
+				}
+			}
+			if !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("LocatorFromAnnotations() got = %v, want %v", got, tt.want)
+			}
+			if gotFound != tt.wantFound {
+				t.Errorf("LocatorFromAnnotations() gotFound = %v, want %v", gotFound, tt.wantFound)
+			}
+		})
+	}
+}

pkg/syncer/spec/spec_process.go

@@ -114,17 +114,30 @@ func (c *Controller) process(ctx context.Context, gvr schema.GroupVersionResourc
 	}
 	clusterName, name := clusters.SplitClusterAwareKey(clusterAwareName)
 
+	namespaceGvr := schema.GroupVersionResource{Group: "", Version: "v1", Resource: "namespaces"}
+
 	desiredNSLocator := shared.NewNamespaceLocator(clusterName, c.syncTargetClusterName, c.syncTargetUID, c.syncTargetName, upstreamNamespace)
 	jsonNSLocator, err := json.Marshal(desiredNSLocator)
 	if err != nil {
 		return err
 	}
-
-	namespaceGvr := schema.GroupVersionResource{Group: "", Version: "v1", Resource: "namespaces"}
 	downstreamNamespaces, err := c.downstreamInformers.ForResource(namespaceGvr).Informer().GetIndexer().ByIndex(byNamespaceLocatorIndexName, string(jsonNSLocator))
 	if err != nil {
 		return err
 	}
+	if len(downstreamNamespaces) == 0 {
+		// case for up to v0.6.0 where we used syncTarget.path in namespace locators
+		desiredNSLocator := shared.NewNamespaceLocatorV060(clusterName, c.syncTargetClusterName, c.syncTargetUID, c.syncTargetName, upstreamNamespace)
+		jsonNSLocator, err := json.Marshal(desiredNSLocator)
+		if err != nil {
+			return err
+		}
+		downstreamNamespaces, err = c.downstreamInformers.ForResource(namespaceGvr).Informer().GetIndexer().ByIndex(byNamespaceLocatorIndexName, string(jsonNSLocator))
+		if err != nil {
+			return err
+		}
+	}
+
 	var downstreamNamespace string
 
 	if len(downstreamNamespaces) == 1 {