From 87d026a90cb46b2c49e7c3a9eae175a34b8bc18f Mon Sep 17 00:00:00 2001 From: AsperforMias Date: Fri, 13 Nov 2026 11:36:02 -0800 Subject: [PATCH 1/2] fix: scope discovery informer known objects to each mesh --- pkg/core/discovery/component.go | 36 +++- pkg/core/discovery/component_test.go | 280 +++++++++++++++++++++++++++ 2 files changed, 315 insertions(+), 1 deletion(-) create mode 100644 pkg/core/discovery/component_test.go diff --git a/pkg/core/discovery/component.go b/pkg/core/discovery/component.go index 09b2004d9..b9f0b33c7 100644 --- a/pkg/core/discovery/component.go +++ b/pkg/core/discovery/component.go @@ -222,11 +222,45 @@ func (d *discoveryComponent) initInformers(cfg *discovery.Config, storeRouter st if err != nil { return nil, fmt.Errorf("cannot find store for resource kind %s", lw.ResourceKind()) } - informer := controller.NewInformerWithOptions(lw, eventBus, resourceStore, keyFunc, controller.Options{ResyncPeriod: 0}) + informerStore := &meshScopedStore{ResourceStore: resourceStore, mesh: cfg.ID} + informer := controller.NewInformerWithOptions(lw, eventBus, informerStore, keyFunc, controller.Options{ResyncPeriod: 0}) informers[i] = informer } return informers, nil } + +// Each discovery list covers one mesh, although resource stores contain all meshes. +type meshScopedStore struct { + store.ResourceStore + mesh string +} + +func (s *meshScopedStore) ListKeys() []string { + objects := s.List() + keys := make([]string, 0, len(objects)) + for _, obj := range objects { + if resource, ok := obj.(coremodel.Resource); ok && resource.ResourceMesh() == s.mesh { + keys = append(keys, resource.ResourceKey()) + } + } + return keys +} + +func (s *meshScopedStore) GetByKey(key string) (interface{}, bool, error) { + obj, exists, err := s.ResourceStore.GetByKey(key) + if err != nil || !exists { + return obj, exists, err + } + resource, ok := obj.(coremodel.Resource) + if !ok { + return nil, false, fmt.Errorf("expected Resource, got %T", obj) + } + if resource.ResourceMesh() != s.mesh { + return nil, false, nil + } + return obj, true, nil +} + func keyFunc(obj interface{}) (string, error) { if r, ok := obj.(coremodel.Resource); ok { return r.ResourceKey(), nil diff --git a/pkg/core/discovery/component_test.go b/pkg/core/discovery/component_test.go new file mode 100644 index 000000000..4dabe66bb --- /dev/null +++ b/pkg/core/discovery/component_test.go @@ -0,0 +1,280 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You 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 discovery + +import ( + "fmt" + "path/filepath" + "testing" + "time" + + "github.com/stretchr/testify/require" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + k8sruntime "k8s.io/apimachinery/pkg/runtime" + "k8s.io/apimachinery/pkg/watch" + "k8s.io/client-go/tools/cache" + + meshproto "github.com/apache/dubbo-admin/api/mesh/v1alpha1" + discoverycfg "github.com/apache/dubbo-admin/pkg/config/discovery" + logcfg "github.com/apache/dubbo-admin/pkg/config/log" + "github.com/apache/dubbo-admin/pkg/core/controller" + "github.com/apache/dubbo-admin/pkg/core/discovery/subscriber" + "github.com/apache/dubbo-admin/pkg/core/events" + "github.com/apache/dubbo-admin/pkg/core/logger" + meshresource "github.com/apache/dubbo-admin/pkg/core/resource/apis/mesh/v1alpha1" + coremodel "github.com/apache/dubbo-admin/pkg/core/resource/model" + "github.com/apache/dubbo-admin/pkg/core/store" + "github.com/apache/dubbo-admin/pkg/store/memory" +) + +type catalogTestFactory struct { + lw controller.ResourceListerWatcher +} + +func (f *catalogTestFactory) Support(t discoverycfg.Type) bool { return t == "catalog-test" } +func (f *catalogTestFactory) NewListWatchers(_ *discoverycfg.Config) ([]controller.ResourceListerWatcher, error) { + return []controller.ResourceListerWatcher{f.lw}, nil +} + +type catalogTestLW struct { + listStarted, allowList, watchStarted chan struct{} + watcher *watch.RaceFreeFakeWatcher +} + +func (l *catalogTestLW) ResourceKind() coremodel.ResourceKind { + return meshresource.ServiceProviderMetadataKind +} +func (l *catalogTestLW) TransformFunc() cache.TransformFunc { return nil } +func (l *catalogTestLW) List(_ metav1.ListOptions) (k8sruntime.Object, error) { + close(l.listStarted) + <-l.allowList + return meshresource.NewServiceProviderMetadataResourceListWithItems(), nil +} +func (l *catalogTestLW) Watch(_ metav1.ListOptions) (watch.Interface, error) { + close(l.watchStarted) + return l.watcher, nil +} + +type relistTestLW struct { + watchStarted chan int + watchers [2]*watch.RaceFreeFakeWatcher + watchCount int +} + +func (l *relistTestLW) ResourceKind() coremodel.ResourceKind { + return meshresource.ServiceProviderMetadataKind +} +func (l *relistTestLW) TransformFunc() cache.TransformFunc { return nil } +func (l *relistTestLW) List(_ metav1.ListOptions) (k8sruntime.Object, error) { + return meshresource.NewServiceProviderMetadataResourceListWithItems(), nil +} +func (l *relistTestLW) Watch(_ metav1.ListOptions) (watch.Interface, error) { + i := l.watchCount + l.watchCount++ + if i >= len(l.watchers) { + return nil, fmt.Errorf("unexpected watch %d", i) + } + l.watchStarted <- i + return l.watchers[i], nil +} + +type catalogTestRouter map[coremodel.ResourceKind]store.ResourceStore + +func (r catalogTestRouter) ResourceKindRoute(k coremodel.ResourceKind) (store.ResourceStore, error) { + s, ok := r[k] + if !ok { + return nil, fmt.Errorf("no store for %s", k) + } + return s, nil +} +func (r catalogTestRouter) ResourceRoute(obj coremodel.Resource) (store.ResourceStore, error) { + return r.ResourceKindRoute(obj.ResourceKind()) +} + +type catalogTestBus struct{ ch chan events.Event } + +func (b *catalogTestBus) Send(e events.Event) { b.ch <- e } +func (b *catalogTestBus) Subscribe(events.Subscriber) error { return nil } +func (b *catalogTestBus) Unsubscribe(events.Subscriber) error { return nil } + +func nextCatalogEvent(t *testing.T, ch <-chan events.Event) events.Event { + t.Helper() + select { + case e := <-ch: + return e + case <-time.After(10 * time.Second): + t.Fatal("timed out waiting for informer event") + return nil + } +} + +func TestDiscoveryInformerKeepsOtherMeshMetadata(t *testing.T) { + logger.Init(&logcfg.Config{Level: logcfg.LevelError, OutputPath: filepath.Join(t.TempDir(), "test.log")}) + for _, tc := range []struct { + mesh, otherMesh string + zkFirst bool + }{ + {"nacos-local", "nacos-local/child", true}, + {"nacos-local", "nacos-local/child", false}, + {"nacos-local/child", "nacos-local", true}, + {"nacos-local/child", "nacos-local", false}, + } { + t.Run(fmt.Sprintf("mesh_%s_zookeeper_before_list_%t", tc.mesh, tc.zkFirst), func(t *testing.T) { + providerStore := memory.NewMemoryResourceStore(meshresource.ServiceProviderMetadataKind) + lifecycleStore := memory.NewMemoryResourceStore(meshresource.LifecycleEventKind) + require.NoError(t, providerStore.Init(nil)) + require.NoError(t, lifecycleStore.Init(nil)) + router := catalogTestRouter{meshresource.ServiceProviderMetadataKind: providerStore, meshresource.LifecycleEventKind: lifecycleStore} + bus := &catalogTestBus{ch: make(chan events.Event, 20)} + lw := &catalogTestLW{listStarted: make(chan struct{}), allowList: make(chan struct{}), watchStarted: make(chan struct{}), watcher: watch.NewRaceFreeFake()} + oldRegistry := registry + registry = newDiscoveryFactoryRegistry() + t.Cleanup(func() { registry = oldRegistry }) + RegisterListWatcherFactory(&catalogTestFactory{lw: lw}) + informers, err := (&discoveryComponent{}).initInformers(&discoverycfg.Config{ID: tc.mesh, Type: "catalog-test"}, router, bus) + require.NoError(t, err) + stale := meshresource.NewServiceProviderMetadataResourceWithAttributes("stale", tc.mesh) + require.NoError(t, providerStore.Add(stale)) + otherMesh := meshresource.NewServiceProviderMetadataResourceWithAttributes("other", tc.otherMesh) + require.NoError(t, providerStore.Add(otherMesh)) + stop := make(chan struct{}) + done := make(chan struct{}) + go func() { defer close(done); informers[0].Run(stop) }() + t.Cleanup(func() { close(stop); <-done }) + <-lw.listStarted + + ingestZK := func() coremodel.Resource { + raw := meshresource.NewZKMetadataResourceWithAttributes("/dubbo/metadata/greet.GreetService/provider/app", "zk-local") + raw.Spec = &meshproto.ZKMetadata{NodePath: raw.Name, NodeData: `{"canonicalName":"greet.GreetService","parameters":{"application":"app"}}`} + err := subscriber.NewZKMetadataEventSubscriber(bus, router).ProcessEvent(events.NewResourceChangedEvent(cache.Added, nil, raw)) + require.NoError(t, err) + e := nextCatalogEvent(t, bus.ch) + require.Equal(t, cache.Added, e.Type()) + return e.NewObj() + } + var zk coremodel.Resource + if tc.zkFirst { + zk = ingestZK() + } + close(lw.allowList) + <-lw.watchStarted + // FIFO queues the sentinel after all initial-list reconciliation deltas. + sentinel := meshresource.NewServiceProviderMetadataResourceWithAttributes("sentinel", tc.mesh) + lw.watcher.Add(sentinel) + var initial []events.Event + for { + e := nextCatalogEvent(t, bus.ch) + if e.NewObj() != nil && e.NewObj().ResourceKey() == sentinel.ResourceKey() { + break + } + initial = append(initial, e) + } + require.Contains(t, eventKeys(initial, cache.Deleted), stale.ResourceKey(), "relist must remove missing same-mesh metadata") + if !tc.zkFirst { + zk = ingestZK() + } + require.NotContains(t, eventKeys(initial, cache.Deleted), zk.ResourceKey(), "another mesh must not be deleted by this list") + require.NotContains(t, eventKeys(initial, cache.Deleted), otherMesh.ResourceKey(), "a mesh with a shared key prefix must remain") + _, exists, err := providerStore.GetByKey(zk.ResourceKey()) + require.NoError(t, err) + require.True(t, exists, "ZooKeeper provider metadata must remain in the shared store") + _, exists, err = providerStore.GetByKey(otherMesh.ResourceKey()) + require.NoError(t, err) + require.True(t, exists) + + updated := sentinel.DeepCopyObject().(*meshresource.ServiceProviderMetadataResource) + updated.Spec.ServiceName = "updated" + lw.watcher.Modify(updated) + e := nextCatalogEvent(t, bus.ch) + require.Equal(t, cache.Updated, e.Type()) + require.Equal(t, "updated", e.NewObj().(*meshresource.ServiceProviderMetadataResource).Spec.ServiceName) + stored, exists, err := providerStore.GetByKey(sentinel.ResourceKey()) + require.NoError(t, err) + require.True(t, exists) + require.Equal(t, "updated", stored.(*meshresource.ServiceProviderMetadataResource).Spec.ServiceName) + deleteTarget := meshresource.NewServiceProviderMetadataResourceWithAttributes("delete-target", tc.mesh) + lw.watcher.Add(deleteTarget) + e = nextCatalogEvent(t, bus.ch) + require.Equal(t, cache.Added, e.Type()) + require.Equal(t, deleteTarget.ResourceKey(), e.NewObj().ResourceKey()) + lw.watcher.Delete(deleteTarget) + e = nextCatalogEvent(t, bus.ch) + require.Equal(t, cache.Deleted, e.Type()) + require.Equal(t, deleteTarget.ResourceKey(), e.OldObj().ResourceKey()) + _, exists, err = providerStore.GetByKey(deleteTarget.ResourceKey()) + require.NoError(t, err) + require.False(t, exists) + }) + } +} + +func TestDiscoveryInformerRelistDeletesStaleSameMesh(t *testing.T) { + logger.Init(&logcfg.Config{Level: logcfg.LevelError, OutputPath: filepath.Join(t.TempDir(), "test.log")}) + providerStore := memory.NewMemoryResourceStore(meshresource.ServiceProviderMetadataKind) + require.NoError(t, providerStore.Init(nil)) + lw := &relistTestLW{ + watchStarted: make(chan int, 2), + watchers: [2]*watch.RaceFreeFakeWatcher{watch.NewRaceFreeFake(), watch.NewRaceFreeFake()}, + } + oldRegistry := registry + registry = newDiscoveryFactoryRegistry() + t.Cleanup(func() { registry = oldRegistry }) + RegisterListWatcherFactory(&catalogTestFactory{lw: lw}) + bus := &catalogTestBus{ch: make(chan events.Event, 20)} + informers, err := (&discoveryComponent{}).initInformers(&discoverycfg.Config{ID: "mesh", Type: "catalog-test"}, catalogTestRouter{meshresource.ServiceProviderMetadataKind: providerStore}, bus) + require.NoError(t, err) + stop := make(chan struct{}) + done := make(chan struct{}) + go func() { defer close(done); informers[0].Run(stop) }() + t.Cleanup(func() { close(stop); <-done }) + awaitWatch := func(expected int) { + t.Helper() + select { + case n := <-lw.watchStarted: + require.Equal(t, expected, n) + case <-time.After(10 * time.Second): + t.Fatal("timed out waiting for watch") + } + } + awaitWatch(0) + stale := meshresource.NewServiceProviderMetadataResourceWithAttributes("stale", "mesh") + lw.watchers[0].Add(stale) + e := nextCatalogEvent(t, bus.ch) + require.Equal(t, cache.Added, e.Type()) + require.Equal(t, stale.ResourceKey(), e.NewObj().ResourceKey()) + + // An expired watch forces a fresh list that no longer contains the object. + lw.watchers[0].Error(&metav1.Status{Status: metav1.StatusFailure, Reason: metav1.StatusReasonExpired, Code: 410}) + awaitWatch(1) + e = nextCatalogEvent(t, bus.ch) + require.Equal(t, cache.Deleted, e.Type()) + require.Equal(t, stale.ResourceKey(), e.OldObj().ResourceKey()) + _, exists, err := providerStore.GetByKey(stale.ResourceKey()) + require.NoError(t, err) + require.False(t, exists) +} + +func eventKeys(es []events.Event, typ cache.DeltaType) []string { + var keys []string + for _, e := range es { + if e.Type() == typ && e.OldObj() != nil { + keys = append(keys, e.OldObj().ResourceKey()) + } + } + return keys +} From 673e2e812862ad1c6a459dd66bbdb31ec21bf630 Mon Sep 17 00:00:00 2001 From: AsperforMias Date: Fri, 13 Nov 2026 22:26:45 -0800 Subject: [PATCH 2/2] test: release blocked catalog list on cleanup and slim isolation cases --- pkg/core/discovery/component_test.go | 238 +++++++++++++++++++-------- 1 file changed, 169 insertions(+), 69 deletions(-) diff --git a/pkg/core/discovery/component_test.go b/pkg/core/discovery/component_test.go index 4dabe66bb..b7e87e97a 100644 --- a/pkg/core/discovery/component_test.go +++ b/pkg/core/discovery/component_test.go @@ -20,6 +20,7 @@ package discovery import ( "fmt" "path/filepath" + "sync" "testing" "time" @@ -123,56 +124,83 @@ func nextCatalogEvent(t *testing.T, ch <-chan events.Event) events.Event { } } +func awaitCatalogSignal(t *testing.T, ch <-chan struct{}, description string) { + t.Helper() + select { + case <-ch: + case <-time.After(10 * time.Second): + t.Fatalf("timed out waiting for %s", description) + } +} + +func startCatalogInformer(t *testing.T, mesh string) (store.ResourceStore, catalogTestRouter, *catalogTestBus, *catalogTestLW, func()) { + t.Helper() + providerStore := memory.NewMemoryResourceStore(meshresource.ServiceProviderMetadataKind) + lifecycleStore := memory.NewMemoryResourceStore(meshresource.LifecycleEventKind) + require.NoError(t, providerStore.Init(nil)) + require.NoError(t, lifecycleStore.Init(nil)) + router := catalogTestRouter{meshresource.ServiceProviderMetadataKind: providerStore, meshresource.LifecycleEventKind: lifecycleStore} + bus := &catalogTestBus{ch: make(chan events.Event, 20)} + lw := &catalogTestLW{listStarted: make(chan struct{}), allowList: make(chan struct{}), watchStarted: make(chan struct{}), watcher: watch.NewRaceFreeFake()} + oldRegistry := registry + registry = newDiscoveryFactoryRegistry() + t.Cleanup(func() { registry = oldRegistry }) + RegisterListWatcherFactory(&catalogTestFactory{lw: lw}) + informers, err := (&discoveryComponent{}).initInformers(&discoverycfg.Config{ID: mesh, Type: "catalog-test"}, router, bus) + require.NoError(t, err) + + var releaseOnce sync.Once + releaseList := func() { releaseOnce.Do(func() { close(lw.allowList) }) } + stop := make(chan struct{}) + done := make(chan struct{}) + go func() { defer close(done); informers[0].Run(stop) }() + t.Cleanup(func() { + close(stop) + releaseList() + select { + case <-done: + case <-time.After(10 * time.Second): + t.Error("timed out waiting for informer to stop") + } + }) + return providerStore, router, bus, lw, releaseList +} + +func ingestCatalogZKMetadata(t *testing.T, bus *catalogTestBus, router catalogTestRouter) coremodel.Resource { + t.Helper() + raw := meshresource.NewZKMetadataResourceWithAttributes("/dubbo/metadata/greet.GreetService/provider/app", "zk-local") + raw.Spec = &meshproto.ZKMetadata{NodePath: raw.Name, NodeData: `{"canonicalName":"greet.GreetService","parameters":{"application":"app"}}`} + err := subscriber.NewZKMetadataEventSubscriber(bus, router).ProcessEvent(events.NewResourceChangedEvent(cache.Added, nil, raw)) + require.NoError(t, err) + e := nextCatalogEvent(t, bus.ch) + require.Equal(t, cache.Added, e.Type()) + return e.NewObj() +} + +func TestDiscoveryInformerCleanupReleasesBlockedList(t *testing.T) { + logger.Init(&logcfg.Config{Level: logcfg.LevelError, OutputPath: filepath.Join(t.TempDir(), "test.log")}) + _, _, _, lw, _ := startCatalogInformer(t, "mesh") + awaitCatalogSignal(t, lw.listStarted, "list to start") + // Return with List still blocked; cleanup must release it and stop the informer. +} + func TestDiscoveryInformerKeepsOtherMeshMetadata(t *testing.T) { logger.Init(&logcfg.Config{Level: logcfg.LevelError, OutputPath: filepath.Join(t.TempDir(), "test.log")}) - for _, tc := range []struct { - mesh, otherMesh string - zkFirst bool - }{ - {"nacos-local", "nacos-local/child", true}, - {"nacos-local", "nacos-local/child", false}, - {"nacos-local/child", "nacos-local", true}, - {"nacos-local/child", "nacos-local", false}, + for _, tc := range []struct{ mesh, otherMesh string }{ + {"nacos-local", "nacos-local/child"}, + {"nacos-local/child", "nacos-local"}, } { - t.Run(fmt.Sprintf("mesh_%s_zookeeper_before_list_%t", tc.mesh, tc.zkFirst), func(t *testing.T) { - providerStore := memory.NewMemoryResourceStore(meshresource.ServiceProviderMetadataKind) - lifecycleStore := memory.NewMemoryResourceStore(meshresource.LifecycleEventKind) - require.NoError(t, providerStore.Init(nil)) - require.NoError(t, lifecycleStore.Init(nil)) - router := catalogTestRouter{meshresource.ServiceProviderMetadataKind: providerStore, meshresource.LifecycleEventKind: lifecycleStore} - bus := &catalogTestBus{ch: make(chan events.Event, 20)} - lw := &catalogTestLW{listStarted: make(chan struct{}), allowList: make(chan struct{}), watchStarted: make(chan struct{}), watcher: watch.NewRaceFreeFake()} - oldRegistry := registry - registry = newDiscoveryFactoryRegistry() - t.Cleanup(func() { registry = oldRegistry }) - RegisterListWatcherFactory(&catalogTestFactory{lw: lw}) - informers, err := (&discoveryComponent{}).initInformers(&discoverycfg.Config{ID: tc.mesh, Type: "catalog-test"}, router, bus) - require.NoError(t, err) + t.Run(tc.mesh, func(t *testing.T) { + providerStore, router, bus, lw, releaseList := startCatalogInformer(t, tc.mesh) + awaitCatalogSignal(t, lw.listStarted, "list to start") stale := meshresource.NewServiceProviderMetadataResourceWithAttributes("stale", tc.mesh) require.NoError(t, providerStore.Add(stale)) otherMesh := meshresource.NewServiceProviderMetadataResourceWithAttributes("other", tc.otherMesh) require.NoError(t, providerStore.Add(otherMesh)) - stop := make(chan struct{}) - done := make(chan struct{}) - go func() { defer close(done); informers[0].Run(stop) }() - t.Cleanup(func() { close(stop); <-done }) - <-lw.listStarted + zk := ingestCatalogZKMetadata(t, bus, router) - ingestZK := func() coremodel.Resource { - raw := meshresource.NewZKMetadataResourceWithAttributes("/dubbo/metadata/greet.GreetService/provider/app", "zk-local") - raw.Spec = &meshproto.ZKMetadata{NodePath: raw.Name, NodeData: `{"canonicalName":"greet.GreetService","parameters":{"application":"app"}}`} - err := subscriber.NewZKMetadataEventSubscriber(bus, router).ProcessEvent(events.NewResourceChangedEvent(cache.Added, nil, raw)) - require.NoError(t, err) - e := nextCatalogEvent(t, bus.ch) - require.Equal(t, cache.Added, e.Type()) - return e.NewObj() - } - var zk coremodel.Resource - if tc.zkFirst { - zk = ingestZK() - } - close(lw.allowList) - <-lw.watchStarted + releaseList() + awaitCatalogSignal(t, lw.watchStarted, "watch to start") // FIFO queues the sentinel after all initial-list reconciliation deltas. sentinel := meshresource.NewServiceProviderMetadataResourceWithAttributes("sentinel", tc.mesh) lw.watcher.Add(sentinel) @@ -185,9 +213,6 @@ func TestDiscoveryInformerKeepsOtherMeshMetadata(t *testing.T) { initial = append(initial, e) } require.Contains(t, eventKeys(initial, cache.Deleted), stale.ResourceKey(), "relist must remove missing same-mesh metadata") - if !tc.zkFirst { - zk = ingestZK() - } require.NotContains(t, eventKeys(initial, cache.Deleted), zk.ResourceKey(), "another mesh must not be deleted by this list") require.NotContains(t, eventKeys(initial, cache.Deleted), otherMesh.ResourceKey(), "a mesh with a shared key prefix must remain") _, exists, err := providerStore.GetByKey(zk.ResourceKey()) @@ -196,33 +221,101 @@ func TestDiscoveryInformerKeepsOtherMeshMetadata(t *testing.T) { _, exists, err = providerStore.GetByKey(otherMesh.ResourceKey()) require.NoError(t, err) require.True(t, exists) - - updated := sentinel.DeepCopyObject().(*meshresource.ServiceProviderMetadataResource) - updated.Spec.ServiceName = "updated" - lw.watcher.Modify(updated) - e := nextCatalogEvent(t, bus.ch) - require.Equal(t, cache.Updated, e.Type()) - require.Equal(t, "updated", e.NewObj().(*meshresource.ServiceProviderMetadataResource).Spec.ServiceName) - stored, exists, err := providerStore.GetByKey(sentinel.ResourceKey()) - require.NoError(t, err) - require.True(t, exists) - require.Equal(t, "updated", stored.(*meshresource.ServiceProviderMetadataResource).Spec.ServiceName) - deleteTarget := meshresource.NewServiceProviderMetadataResourceWithAttributes("delete-target", tc.mesh) - lw.watcher.Add(deleteTarget) - e = nextCatalogEvent(t, bus.ch) - require.Equal(t, cache.Added, e.Type()) - require.Equal(t, deleteTarget.ResourceKey(), e.NewObj().ResourceKey()) - lw.watcher.Delete(deleteTarget) - e = nextCatalogEvent(t, bus.ch) - require.Equal(t, cache.Deleted, e.Type()) - require.Equal(t, deleteTarget.ResourceKey(), e.OldObj().ResourceKey()) - _, exists, err = providerStore.GetByKey(deleteTarget.ResourceKey()) - require.NoError(t, err) - require.False(t, exists) }) } } +func TestDiscoveryInformerKeepsLateZKMetadata(t *testing.T) { + logger.Init(&logcfg.Config{Level: logcfg.LevelError, OutputPath: filepath.Join(t.TempDir(), "test.log")}) + providerStore := memory.NewMemoryResourceStore(meshresource.ServiceProviderMetadataKind) + lifecycleStore := memory.NewMemoryResourceStore(meshresource.LifecycleEventKind) + require.NoError(t, providerStore.Init(nil)) + require.NoError(t, lifecycleStore.Init(nil)) + router := catalogTestRouter{meshresource.ServiceProviderMetadataKind: providerStore, meshresource.LifecycleEventKind: lifecycleStore} + bus := &catalogTestBus{ch: make(chan events.Event, 20)} + lw := &relistTestLW{ + watchStarted: make(chan int, 2), + watchers: [2]*watch.RaceFreeFakeWatcher{watch.NewRaceFreeFake(), watch.NewRaceFreeFake()}, + } + oldRegistry := registry + registry = newDiscoveryFactoryRegistry() + t.Cleanup(func() { registry = oldRegistry }) + RegisterListWatcherFactory(&catalogTestFactory{lw: lw}) + informers, err := (&discoveryComponent{}).initInformers(&discoverycfg.Config{ID: "nacos-local", Type: "catalog-test"}, router, bus) + require.NoError(t, err) + stop := make(chan struct{}) + done := make(chan struct{}) + go func() { defer close(done); informers[0].Run(stop) }() + t.Cleanup(func() { + close(stop) + select { + case <-done: + case <-time.After(10 * time.Second): + t.Error("timed out waiting for informer to stop") + } + }) + awaitWatch := func(expected int) { + t.Helper() + select { + case n := <-lw.watchStarted: + require.Equal(t, expected, n) + case <-time.After(10 * time.Second): + t.Fatal("timed out waiting for watch") + } + } + awaitWatch(0) + zk := ingestCatalogZKMetadata(t, bus, router) + // A later relist with an empty catalog list would delete this object if + // known-objects were not scoped to the informer's mesh. + lw.watchers[0].Error(&metav1.Status{Status: metav1.StatusFailure, Reason: metav1.StatusReasonExpired, Code: 410}) + awaitWatch(1) + sentinel := meshresource.NewServiceProviderMetadataResourceWithAttributes("sentinel", "nacos-local") + lw.watchers[1].Add(sentinel) + var afterRelist []events.Event + for { + e := nextCatalogEvent(t, bus.ch) + if e.NewObj() != nil && e.NewObj().ResourceKey() == sentinel.ResourceKey() { + break + } + afterRelist = append(afterRelist, e) + } + require.NotContains(t, eventKeys(afterRelist, cache.Deleted), zk.ResourceKey(), "late ZooKeeper metadata must not be deleted") + _, exists, err := providerStore.GetByKey(zk.ResourceKey()) + require.NoError(t, err) + require.True(t, exists, "late ZooKeeper metadata must remain in the shared store") +} + +func TestDiscoveryInformerWatchAddUpdateDelete(t *testing.T) { + logger.Init(&logcfg.Config{Level: logcfg.LevelError, OutputPath: filepath.Join(t.TempDir(), "test.log")}) + providerStore, _, bus, lw, releaseList := startCatalogInformer(t, "mesh") + awaitCatalogSignal(t, lw.listStarted, "list to start") + releaseList() + awaitCatalogSignal(t, lw.watchStarted, "watch to start") + + obj := meshresource.NewServiceProviderMetadataResourceWithAttributes("provider", "mesh") + lw.watcher.Add(obj) + e := nextCatalogEvent(t, bus.ch) + require.Equal(t, cache.Added, e.Type()) + require.Equal(t, obj.ResourceKey(), e.NewObj().ResourceKey()) + updated := obj.DeepCopyObject().(*meshresource.ServiceProviderMetadataResource) + updated.Spec.ServiceName = "updated" + lw.watcher.Modify(updated) + e = nextCatalogEvent(t, bus.ch) + require.Equal(t, cache.Updated, e.Type()) + require.Equal(t, "updated", e.NewObj().(*meshresource.ServiceProviderMetadataResource).Spec.ServiceName) + stored, exists, err := providerStore.GetByKey(obj.ResourceKey()) + require.NoError(t, err) + require.True(t, exists) + require.Equal(t, "updated", stored.(*meshresource.ServiceProviderMetadataResource).Spec.ServiceName) + lw.watcher.Delete(updated) + e = nextCatalogEvent(t, bus.ch) + require.Equal(t, cache.Deleted, e.Type()) + require.Equal(t, obj.ResourceKey(), e.OldObj().ResourceKey()) + _, exists, err = providerStore.GetByKey(obj.ResourceKey()) + require.NoError(t, err) + require.False(t, exists) +} + func TestDiscoveryInformerRelistDeletesStaleSameMesh(t *testing.T) { logger.Init(&logcfg.Config{Level: logcfg.LevelError, OutputPath: filepath.Join(t.TempDir(), "test.log")}) providerStore := memory.NewMemoryResourceStore(meshresource.ServiceProviderMetadataKind) @@ -241,7 +334,14 @@ func TestDiscoveryInformerRelistDeletesStaleSameMesh(t *testing.T) { stop := make(chan struct{}) done := make(chan struct{}) go func() { defer close(done); informers[0].Run(stop) }() - t.Cleanup(func() { close(stop); <-done }) + t.Cleanup(func() { + close(stop) + select { + case <-done: + case <-time.After(10 * time.Second): + t.Error("timed out waiting for informer to stop") + } + }) awaitWatch := func(expected int) { t.Helper() select {