CBG-4735: Remove the _globalSync xattr with purge to avoid attachment metadata hanging around (#7667)

Author: bbrks

base/util.go

@@ -1814,3 +1814,14 @@ func SlicesEqualIgnoreOrder[T comparable](a, b []T) bool {
 	}
 	return true
 }
+
+// KeysPresent returns the subset of keys that are present in m, preserving input order of keys.
+func KeysPresent[K comparable, V any](m map[K]V, keys []K) []K {
+	result := make([]K, 0, len(keys))
+	for _, k := range keys {
+		if _, ok := m[k]; ok {
+			result = append(result, k)
+		}
+	}
+	return result
+}

base/util_test.go

@@ -1807,3 +1807,50 @@ func TestSlicesEqualUnordered(t *testing.T) {
 		})
 	}
 }
+
+func TestKeysPresent(t *testing.T) {
+	tests := []struct {
+		name string
+		m    map[string]int
+		keys []string
+		want []string
+	}{
+		{
+			name: "all present",
+			m:    map[string]int{"a": 1, "b": 2, "c": 3},
+			keys: []string{"a", "b"},
+			want: []string{"a", "b"},
+		},
+		{
+			name: "some present",
+			m:    map[string]int{"a": 1, "b": 2},
+			keys: []string{"a", "x", "b", "y"},
+			want: []string{"a", "b"},
+		},
+		{
+			name: "none present",
+			m:    map[string]int{"a": 1},
+			keys: []string{"x", "y"},
+			want: []string{},
+		},
+		{
+			name: "empty keys",
+			m:    map[string]int{"a": 1},
+			keys: nil,
+			want: []string{},
+		},
+		{
+			name: "empty map",
+			m:    map[string]int{},
+			keys: []string{"a"},
+			want: []string{},
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			got := KeysPresent(tc.m, tc.keys)
+			assert.Equal(t, tc.want, got)
+		})
+	}
+}

db/crud.go

@@ -2867,7 +2867,7 @@ func (db *DatabaseCollectionWithUser) DeleteDoc(ctx context.Context, docid strin
 
 // Purges a document from the bucket (no tombstone)
 func (db *DatabaseCollectionWithUser) Purge(ctx context.Context, key string, needsAudit bool) error {
-	doc, err := db.GetDocument(ctx, key, DocUnmarshalAll)
+	doc, rawBucketDoc, err := db.GetDocumentWithRaw(ctx, key, DocUnmarshalAll)
 	if err != nil {
 		return err
 	}
@@ -2892,8 +2892,15 @@ func (db *DatabaseCollectionWithUser) Purge(ctx context.Context, key string, nee
 	}
 
 	if db.UseXattrs() {
-		err := db.dataStore.DeleteWithXattrs(ctx, key, []string{base.SyncXattrName})
-		if err != nil {
+		// Clean up _sync and _globalSync (if present). Leave _vv and _mou since they are also shared by XDCR/Eventing.
+		xattrsToDelete := []string{base.SyncXattrName, base.GlobalXattrName}
+		// TODO: CBG-4796 - we currently need to determine a list of present xattrs before we delete to avoid differences
+		// between Rosmar and Couchbase Server implementations of DeleteWithXattrs and GetWithXattrs.
+		var presentXattrsToDelete []string
+		if rawBucketDoc != nil && rawBucketDoc.Xattrs != nil {
+			presentXattrsToDelete = base.KeysPresent(rawBucketDoc.Xattrs, xattrsToDelete)
+		}
+		if err := db.dataStore.DeleteWithXattrs(ctx, key, presentXattrsToDelete); err != nil {
 			return err
 		}
 	} else {

rest/adminapitest/admin_api_test.go

@@ -9,6 +9,7 @@
 package adminapitest
 
 import (
+	"encoding/base64"
 	"encoding/json"
 	"errors"
 	"fmt"
@@ -1789,6 +1790,52 @@ func TestPurgeWithSomeInvalidDocs(t *testing.T) {
 	rest.RequireStatus(t, rt.SendAdminRequest("PUT", "/{{.keyspace}}/doc2", `{"moo":"car"}`), 409)
 }
 
+// TestPurgeWithOldAttachment ensures that purging a document with an attachment actually removes it and a recreated document does not have the old attachment.
+func TestPurgeWithOldAttachment(t *testing.T) {
+	rt := rest.NewRestTester(t, nil)
+	defer rt.Close()
+
+	const att1 = "first attachment"
+	att1Data := base64.StdEncoding.EncodeToString([]byte(att1))
+	_ = rt.PutDocWithAttachment("doc1", `{"foo":"doc1"}`, "att1", att1Data)
+
+	rawBody, rawXattrs, _, err := rt.GetSingleDataStore().GetWithXattrs(t.Context(), "doc1", []string{base.SyncXattrName, base.GlobalXattrName})
+	require.NoError(t, err)
+	assert.NotNil(t, rawBody)
+	assert.NotNil(t, rawXattrs)
+	var globalSync db.GlobalSyncData
+	require.NoError(t, json.Unmarshal(rawXattrs[base.GlobalXattrName], &globalSync))
+	assert.Equal(t, len(att1), int(globalSync.Attachments["att1"].(map[string]any)["length"].(float64)))
+
+	response := rt.SendAdminRequest("POST", "/{{.keyspace}}/_purge", `{"doc1":["*"]}`)
+	rest.RequireStatus(t, response, http.StatusOK)
+	var body db.Body
+	require.NoError(t, base.JSONUnmarshal(response.Body.Bytes(), &body))
+	assert.Equal(t, db.Body{"purged": map[string]any{"doc1": []interface{}{"*"}}}, body)
+
+	// inspect bucket doc to ensure SG's xattrs are gone
+	rawBody, rawXattrs, _, err = rt.GetSingleDataStore().GetWithXattrs(t.Context(), "doc1", []string{base.SyncXattrName, base.GlobalXattrName})
+	assert.Error(t, err)
+	assert.True(t, base.IsDocNotFoundError(err))
+	assert.Nil(t, rawBody)
+	assert.Empty(t, rawXattrs)
+
+	// Overwriting the document here is intentional: after purging, we want to verify that re-inserting the document does not resurrect any previous attachments or metadata.
+	// This ensures the purge operation fully removed all traces of the original document, and that the new insert starts from a clean state.
+	const att2 = "att two"
+	att2Data := base64.StdEncoding.EncodeToString([]byte(att2))
+	_ = rt.PutDocWithAttachment("doc1", `{"foo":"doc1"}`, "att2", att2Data)
+
+	rawBody, rawXattrs, _, err = rt.GetSingleDataStore().GetWithXattrs(t.Context(), "doc1", []string{base.SyncXattrName, base.GlobalXattrName})
+	require.NoError(t, err)
+	assert.NotNil(t, rawBody)
+	assert.NotNil(t, rawXattrs)
+	globalSync = db.GlobalSyncData{}
+	require.NoError(t, json.Unmarshal(rawXattrs[base.GlobalXattrName], &globalSync))
+	assert.NotContains(t, globalSync.Attachments, "att1")
+	assert.Equal(t, len(att2), int(globalSync.Attachments["att2"].(map[string]any)["length"].(float64)))
+}
+
 // TestRawRedaction tests the /_raw endpoint with and without redaction
 // intentionally does string matching on redactable strings to avoid any regressions if we move around metadata without updating the test
 func TestRawRedaction(t *testing.T) {