Skip to content

RAGFlow is an agent-native database: a Retrieval-Augmented Generation (RAG) engine that grew into context infrastructure.

fix(models): publish the provider catalog through an atomic pointer and drop the dao-side cache so concurrent readers and publishers no longer race (#21749)

ciel527fd0722628
diff --git a/internal/dao/database.go b/internal/dao/database.go
index 7494099597..22d57ad765 100644
--- a/internal/dao/database.go
+++ b/internal/dao/database.go
@@ -488,7 +488,6 @@ func InitDB(ctx context.Context, migrateDB bool) error {
common.Fatal("Failed to load model providers", zap.Error(err))
}
- modelProviderManager = models.GetProviderManager()
common.Info("Model providers loaded successfully")
return nil
diff --git a/internal/dao/model_provider.go b/internal/dao/model_provider.go
index e221e384e2..c466c67826 100644
--- a/internal/dao/model_provider.go
+++ b/internal/dao/model_provider.go
@@ -28,36 +28,28 @@ import (
"ragflow/internal/entity/models"
)
-var modelProviderManager *models.ProviderManager
-var modelProviderManagerMu sync.Mutex
+// modelProviderLoadOnce guards the fallback load for callers that run without
+// InitDB. The catalog itself is published atomically by the models package.
+var modelProviderLoadOnce sync.Once
// GetModelProviderManager returns the process-wide model provider catalog.
// The catalog is parsed from the provider JSON files under conf/models, so it
// has no SQL backend and no connection of its own; InitDB seeds it at startup
// and the fallback below covers callers that run without InitDB.
func GetModelProviderManager() *models.ProviderManager {
- if modelProviderManager != nil {
- return modelProviderManager
+ if pm := models.GetProviderManager(); pm != nil {
+ return pm
}
-
- modelProviderManagerMu.Lock()
- defer modelProviderManagerMu.Unlock()
- if modelProviderManager != nil {
- return modelProviderManager
- }
- if existing := models.GetProviderManager(); existing != nil {
- modelProviderManager = existing
- return modelProviderManager
- }
- modelConfigDir, err := findModelConfigDir()
- if err != nil {
- common.Fatal("Failed to locate model providers", zap.Error(err))
- }
- if err = models.InitProviderManager(modelConfigDir); err != nil {
- common.Fatal("Failed to load model providers", zap.Error(err))
- }
- modelProviderManager = models.GetProviderManager()
- return modelProviderManager
+ modelProviderLoadOnce.Do(func() {
+ modelConfigDir, err := findModelConfigDir()
+ if err != nil {
+ common.Fatal("Failed to locate model providers", zap.Error(err))
+ }
+ if err = models.InitProviderManager(modelConfigDir); err != nil {
+ common.Fatal("Failed to load model providers", zap.Error(err))
+ }
+ })
+ return models.GetProviderManager()
}
func findModelConfigDir() (string, error) {
diff --git a/internal/dao/model_provider_test.go b/internal/dao/model_provider_test.go
new file mode 100644
index 0000000000..78b32d26aa
--- /dev/null
+++ b/internal/dao/model_provider_test.go
@@ -0,0 +1,56 @@
+//
+// Copyright 2026 The InfiniFlow Authors. All Rights Reserved.
+//
+// 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 dao
+
+import (
+ "sync"
+ "testing"
+
+ "ragflow/internal/entity/models"
+)
+
+// TestGetModelProviderManagerServesPublishedCatalog pins that the getter reads
+// the catalog the models package publishes and returns the same immutable
+// snapshot to concurrent callers. The concurrent block is what exercises the
+// publication path under `-race`.
+func TestGetModelProviderManagerServesPublishedCatalog(t *testing.T) {
+ first := GetModelProviderManager()
+ if first == nil {
+ t.Fatal("GetModelProviderManager returned nil")
+ }
+ if published := models.GetProviderManager(); published != first {
+ t.Fatal("GetModelProviderManager returned a catalog the models package did not publish")
+ }
+
+ const callers = 8
+ results := make([]*models.ProviderManager, callers)
+ var wg sync.WaitGroup
+ for i := range callers {
+ wg.Add(1)
+ go func() {
+ defer wg.Done()
+ results[i] = GetModelProviderManager()
+ }()
+ }
+ wg.Wait()
+
+ for i, got := range results {
+ if got != first {
+ t.Fatalf("caller %d got a different catalog pointer", i)
+ }
+ }
+}
diff --git a/internal/entity/models/get_driver_test.go b/internal/entity/models/get_driver_test.go
index 5f78a1258c..1b976d408a 100644
--- a/internal/entity/models/get_driver_test.go
+++ b/internal/entity/models/get_driver_test.go
@@ -105,9 +105,9 @@ func TestGetPreconfiguredDriverProviderNotFound(t *testing.T) {
func TestGetPreconfiguredDriverManagerNotInitialized(t *testing.T) {
// Save and reset the global so we can test the nil-manager path.
- saved := providerManager
- providerManager = nil
- defer func() { providerManager = saved }()
+ saved := GetProviderManager()
+ setProviderManager(nil)
+ defer setProviderManager(saved)
_, err := GetPreconfiguredDriver("Tongyi-Qianwen", "")
if err == nil {
diff --git a/internal/entity/models/hostinger_router_test.go b/internal/entity/models/hostinger_router_test.go
index 4a9c63ca09..2f3497d1fb 100644
--- a/internal/entity/models/hostinger_router_test.go
+++ b/internal/entity/models/hostinger_router_test.go
@@ -202,8 +202,8 @@ func TestHostingerRouterListModelsAndCheckConnection(t *testing.T) {
// reported as chat-only, while other models keep name-inferred types.
func TestHostingerRouterListModelsKeepsCatalogueTypes(t *testing.T) {
withSSRFBypass(t)
- prev := providerManager
- defer func() { providerManager = prev }()
+ saved := GetProviderManager()
+ defer setProviderManager(saved)
dir, restore := setupProviderTestDir(t, "hostinger_router.json")
defer restore()
if err := InitProviderManager(dir); err != nil {
diff --git a/internal/entity/models/model.go b/internal/entity/models/model.go
index fb51512d21..6c0aaee0bf 100644
--- a/internal/entity/models/model.go
+++ b/internal/entity/models/model.go
@@ -25,6 +25,7 @@ import (
"sort"
"strconv"
"strings"
+ "sync/atomic"
)
// ReasoningSimple represents simple reasoning capability
@@ -237,10 +238,21 @@ func decodeProviderConfig(data []byte) (Provider, error) {
return provider, nil
}
-var providerManager *ProviderManager
+// providerManager holds the published catalog. The catalog is immutable once
+// built, so publishing it through an atomic pointer gives every reader a fully
+// initialized snapshot without a lock.
+var providerManager atomic.Pointer[ProviderManager]
+// GetProviderManager returns the published provider catalog, or nil when no
+// catalog has been published yet.
func GetProviderManager() *ProviderManager {
- return providerManager
+ return providerManager.Load()
+}
+
+// setProviderManager publishes a catalog built by InitProviderManager. Tests
+// use it to install and restore fixture catalogs.
+func setProviderManager(pm *ProviderManager) {
+ providerManager.Store(pm)
}
// InitProviderManager creates a new ProviderManager by reading all JSON files from a directory
@@ -355,11 +367,11 @@ func InitProviderManager(dirPath string) error {
}
}
- providerManager = &ProviderManager{
+ setProviderManager(&ProviderManager{
Providers: providers,
AllModels: allModels.Models,
Alias2ModelIndex: alias2ModelIndex,
- }
+ })
return nil
}
diff --git a/internal/entity/models/model_test.go b/internal/entity/models/model_test.go
index 9c89be14f1..eeba12fb85 100644
--- a/internal/entity/models/model_test.go
+++ b/internal/entity/models/model_test.go
@@ -29,6 +29,7 @@ import (
"path/filepath"
"sort"
"strings"
+ "sync"
"testing"
"ragflow/internal/tokenizer"
@@ -1014,3 +1015,44 @@ func sortedKeys(set map[string]bool) []string {
sort.Strings(out)
return out
}
+
+// TestProviderManagerPublishIsVisibleToConcurrentReaders pins the publication
+// contract: InitProviderManager hands the catalog to an atomic pointer, so a
+// reader running while a publish is in flight observes a complete catalog
+// instead of racing on the field. Run with -race to catch a regression back to
+// a plain package variable.
+func TestProviderManagerPublishIsVisibleToConcurrentReaders(t *testing.T) {
+ saved := GetProviderManager()
+ published := &ProviderManager{Providers: []Provider{{Name: "atomic-fixture"}}}
+ setProviderManager(published)
+
+ stop := make(chan struct{})
+ var wg sync.WaitGroup
+ wg.Add(1)
+ go func() {
+ defer wg.Done()
+ for {
+ select {
+ case <-stop:
+ return
+ default:
+ setProviderManager(published)
+ }
+ }
+ }()
+ t.Cleanup(func() {
+ close(stop)
+ wg.Wait()
+ setProviderManager(saved)
+ })
+
+ for i := 0; i < 1000; i++ {
+ got := GetProviderManager()
+ if got == nil {
+ t.Fatal("GetProviderManager returned nil while a catalog was published")
+ }
+ if len(got.Providers) != 1 || got.Providers[0].Name != "atomic-fixture" {
+ t.Fatalf("reader observed a catalog that was never published: %+v", got)
+ }
+ }
+}
diff --git a/internal/entity/models/nvidia_test.go b/internal/entity/models/nvidia_test.go
index e3d1b7b540..ddb88f1370 100644
--- a/internal/entity/models/nvidia_test.go
+++ b/internal/entity/models/nvidia_test.go
@@ -230,15 +230,15 @@ func TestNvidiaCatalogResourceRejectsMalformedDeprecation(t *testing.T) {
func withNvidiaProviderManager(t *testing.T, models []*Model) {
t.Helper()
- saved := providerManager
- providerManager = &ProviderManager{
+ saved := GetProviderManager()
+ setProviderManager(&ProviderManager{
Providers: []Provider{{
Name: "NVIDIA",
URL: map[string]string{"default": "https://integrate.api.nvidia.com/v1"},
Models: models,
}},
- }
- t.Cleanup(func() { providerManager = saved })
+ })
+ t.Cleanup(func() { setProviderManager(saved) })
}
func TestNvidiaResolveEndpointUsesModelURL(t *testing.T) {
@@ -286,9 +286,9 @@ func TestNvidiaResolveEndpointFallsBackToAssembly(t *testing.T) {
}
func TestNvidiaResolveEndpointIgnoresManagerWhenNil(t *testing.T) {
- saved := providerManager
- providerManager = nil
- defer func() { providerManager = saved }()
+ saved := GetProviderManager()
+ setProviderManager(nil)
+ defer setProviderManager(saved)
driver := NewNvidiaModel(
map[string]string{"default": "https://integrate.api.nvidia.com/v1"},
diff --git a/internal/service/tenant_test.go b/internal/service/tenant_test.go
index 2940f59aef..1e50ef1927 100644
--- a/internal/service/tenant_test.go
+++ b/internal/service/tenant_test.go
@@ -18,7 +18,6 @@ package service
import (
"testing"
- _ "unsafe"
"github.com/glebarez/sqlite"
"gorm.io/gorm"
@@ -29,9 +28,6 @@ import (
"ragflow/internal/entity/models"
)
-//go:linkname daoModelProviderManager ragflow/internal/dao.modelProviderManager
-var daoModelProviderManager *models.ProviderManager
-
func setupTenantPermissionTestDB(t *testing.T) *gorm.DB {
t.Helper()
db, err := gorm.Open(sqlite.Open("file:"+t.Name()+"?mode=memory&cache=shared"), &gorm.Config{TranslateError: true})
@@ -216,7 +212,6 @@ func TestSetModelSettings_WithModelID(t *testing.T) {
if err != nil {
t.Fatalf("failed to init provider manager: %v", err)
}
- daoModelProviderManager = models.GetProviderManager()
// 2. Migrate tables
err = db.AutoMigrate(