fix(config): synchronize rootConfig publication and access

- guard global rootConfig pointer with RWMutex-backed accessors
- make config.Load build a local RootConfig and initialize before publishing
- route config consumers through GetRootConfig instead of direct global reads
- avoid in-place global mutation in SetConsumerConfig
- add concurrent Set/Get regression test for root config

Fixes: #3247

Author: xxs588

config/config_loader.go

@@ -19,6 +19,7 @@ package config
 
 import (
 	"errors"
+	"sync"
 )
 
 import (
@@ -34,9 +35,22 @@ import (
 )
 
 var (
-	rootConfig = NewRootConfigBuilder().Build()
+	rootConfigMu sync.RWMutex
+	rootConfig   = NewRootConfigBuilder().Build()
 )
 
+func getRootConfigInternal() *RootConfig {
+	rootConfigMu.RLock()
+	defer rootConfigMu.RUnlock()
+	return rootConfig
+}
+
+func setRootConfigInternal(rc *RootConfig) {
+	rootConfigMu.Lock()
+	defer rootConfigMu.Unlock()
+	rootConfig = rc
+}
+
 func init() {
 	log := zap.NewDefault()
 	logger.SetLogger(log)
@@ -45,39 +59,40 @@ func init() {
 func Load(opts ...LoaderConfOption) error {
 	// conf
 	conf := NewLoaderConf(opts...)
+	loadConfig := conf.rc
+
 	if conf.rc == nil {
+		loadConfig = NewRootConfigBuilder().Build()
 		koan := GetConfigResolver(conf)
 		koan = conf.MergeConfig(koan)
-		if err := koan.UnmarshalWithConf(rootConfig.Prefix(),
-			rootConfig, koanf.UnmarshalConf{Tag: "yaml"}); err != nil {
+		if err := koan.UnmarshalWithConf(loadConfig.Prefix(),
+			loadConfig, koanf.UnmarshalConf{Tag: "yaml"}); err != nil {
 			return err
 		}
-	} else {
-		rootConfig = conf.rc
 	}
 
-	if err := rootConfig.Init(); err != nil {
+	if err := loadConfig.Init(); err != nil {
 		return err
 	}
 	return nil
 }
 
 func check() error {
-	if rootConfig == nil {
+	if GetRootConfig() == nil {
 		return errors.New("execute the config.Load() method first")
 	}
 	return nil
 }
 
 // GetRPCService get rpc service for consumer
 func GetRPCService(name string) common.RPCService {
-	return rootConfig.Consumer.References[name].GetRPCService()
+	return GetRootConfig().Consumer.References[name].GetRPCService()
 }
 
 // RPCService create rpc service for consumer
 func RPCService(service common.RPCService) {
 	ref := common.GetReference(service)
-	rootConfig.Consumer.References[ref].Implement(service)
+	GetRootConfig().Consumer.References[ref].Implement(service)
 }
 
 // GetMetricConfig find the MetricsConfig
@@ -95,17 +110,17 @@ func GetMetricConfig() *MetricsConfig {
 	//	}
 	//}
 	//return GetBaseConfig().Metrics
-	return rootConfig.Metrics
+	return GetRootConfig().Metrics
 }
 
 func GetTracingConfig(tracingKey string) *TracingConfig {
-	return rootConfig.Tracing[tracingKey]
+	return GetRootConfig().Tracing[tracingKey]
 }
 
 func GetMetadataReportConfg() *MetadataReportConfig {
-	return rootConfig.MetadataReport
+	return GetRootConfig().MetadataReport
 }
 
 func IsProvider() bool {
-	return len(rootConfig.Provider.Services) > 0
+	return len(GetRootConfig().Provider.Services) > 0
 }

config/consumer_config.go

@@ -133,7 +133,7 @@ func (cc *ConsumerConfig) Load() {
 				// use interface name defined by pb
 				refConfig.InterfaceName = triplePBService.XXX_InterfaceName()
 			}
-			if err := refConfig.Init(rootConfig); err != nil {
+			if err := refConfig.Init(GetRootConfig()); err != nil {
 				logger.Errorf(fmt.Sprintf("reference with registeredTypeName = %s init failed! err: %#v", registeredTypeName, err))
 				continue
 			}
@@ -185,7 +185,14 @@ func (cc *ConsumerConfig) Load() {
 
 // SetConsumerConfig sets consumerConfig by @c
 func SetConsumerConfig(c ConsumerConfig) {
-	rootConfig.Consumer = &c
+	rc := GetRootConfig()
+	if rc == nil {
+		SetRootConfig(RootConfig{Consumer: &c})
+		return
+	}
+	next := *rc
+	next.Consumer = &c
+	SetRootConfig(next)
 }
 
 func newEmptyConsumerConfig() *ConsumerConfig {

config/graceful_shutdown.go

@@ -63,11 +63,12 @@ func gracefulShutdownInit() {
 	if !exist {
 		return
 	}
-	if filter, ok := gracefulShutdownConsumerFilter.(Setter); ok && rootConfig.Shutdown != nil {
+	rc := GetRootConfig()
+	if filter, ok := gracefulShutdownConsumerFilter.(Setter); ok && rc != nil && rc.Shutdown != nil {
 		filter.Set(constant.GracefulShutdownFilterShutdownConfig, GetShutDown())
 	}
 
-	if filter, ok := gracefulShutdownProviderFilter.(Setter); ok && rootConfig.Shutdown != nil {
+	if filter, ok := gracefulShutdownProviderFilter.(Setter); ok && rc != nil && rc.Shutdown != nil {
 		filter.Set(constant.GracefulShutdownFilterShutdownConfig, GetShutDown())
 	}
 
@@ -127,21 +128,22 @@ func destroyAllRegistries() {
 func destroyProtocols() {
 	logger.Info("Graceful shutdown --- Destroy protocols. ")
 
-	if rootConfig.Protocols == nil {
+	rc := GetRootConfig()
+	if rc == nil || rc.Protocols == nil {
 		return
 	}
 
-	consumerProtocols := getConsumerProtocols()
+	consumerProtocols := getConsumerProtocols(rc)
 
-	destroyProviderProtocols(consumerProtocols)
+	destroyProviderProtocols(rc, consumerProtocols)
 	destroyConsumerProtocols(consumerProtocols)
 }
 
 // destroyProviderProtocols destroys the provider's protocol.
 // if the protocol is consumer's protocol too, we will keep it
-func destroyProviderProtocols(consumerProtocols *gxset.HashSet) {
+func destroyProviderProtocols(rc *RootConfig, consumerProtocols *gxset.HashSet) {
 	logger.Info("Graceful shutdown --- First destroy provider's protocols. ")
-	for _, protocol := range rootConfig.Protocols {
+	for _, protocol := range rc.Protocols {
 		// the protocol is the consumer's protocol too, we can not destroy it.
 		if consumerProtocols.Contains(protocol.Name) {
 			continue
@@ -159,18 +161,19 @@ func destroyConsumerProtocols(consumerProtocols *gxset.HashSet) {
 
 func waitAndAcceptNewRequests() {
 	logger.Info("Graceful shutdown --- Keep waiting and accept new requests for a short time. ")
-	if rootConfig.Shutdown == nil {
+	rc := GetRootConfig()
+	if rc == nil || rc.Shutdown == nil {
 		return
 	}
 
-	time.Sleep(rootConfig.Shutdown.GetConsumerUpdateWaitTime())
+	time.Sleep(rc.Shutdown.GetConsumerUpdateWaitTime())
 
-	timeout := rootConfig.Shutdown.GetStepTimeout()
+	timeout := rc.Shutdown.GetStepTimeout()
 	// ignore this step
 	if timeout < 0 {
 		return
 	}
-	waitingProviderProcessedTimeout(rootConfig.Shutdown)
+	waitingProviderProcessedTimeout(rc.Shutdown)
 }
 
 func waitingProviderProcessedTimeout(shutdownConfig *ShutdownConfig) {
@@ -193,12 +196,13 @@ func waitingProviderProcessedTimeout(shutdownConfig *ShutdownConfig) {
 // for provider. It will wait for processing receiving requests
 func waitForSendingAndReceivingRequests() {
 	logger.Info("Graceful shutdown --- Keep waiting until sending/accepting requests finish or timeout. ")
-	if rootConfig == nil || rootConfig.Shutdown == nil {
+	rc := GetRootConfig()
+	if rc == nil || rc.Shutdown == nil {
 		// ignore this step
 		return
 	}
-	rootConfig.Shutdown.RejectRequest.Store(true)
-	waitingConsumerProcessedTimeout(rootConfig.Shutdown)
+	rc.Shutdown.RejectRequest.Store(true)
+	waitingConsumerProcessedTimeout(rc.Shutdown)
 }
 
 func waitingConsumerProcessedTimeout(shutdownConfig *ShutdownConfig) {
@@ -217,21 +221,22 @@ func waitingConsumerProcessedTimeout(shutdownConfig *ShutdownConfig) {
 
 func totalTimeout() time.Duration {
 	timeout := defaultShutDownTime
-	if rootConfig.Shutdown != nil && rootConfig.Shutdown.GetTimeout() > timeout {
-		timeout = rootConfig.Shutdown.GetTimeout()
+	rc := GetRootConfig()
+	if rc != nil && rc.Shutdown != nil && rc.Shutdown.GetTimeout() > timeout {
+		timeout = rc.Shutdown.GetTimeout()
 	}
 
 	return timeout
 }
 
 // we can not get the protocols from consumerConfig because some protocol don't have configuration, like jsonrpc.
-func getConsumerProtocols() *gxset.HashSet {
+func getConsumerProtocols(rc *RootConfig) *gxset.HashSet {
 	result := gxset.NewSet()
-	if rootConfig.Consumer == nil || rootConfig.Consumer.References == nil {
+	if rc == nil || rc.Consumer == nil || rc.Consumer.References == nil {
 		return result
 	}
 
-	for _, reference := range rootConfig.Consumer.References {
+	for _, reference := range rc.Consumer.References {
 		result.Add(reference.Protocol)
 	}
 	return result

config/metadata_config.go

@@ -63,7 +63,7 @@ func initMetadata(rc *RootConfig) error {
 func getMetadataPort(rc *RootConfig) int {
 	port := rc.Application.MetadataServicePort
 	if port == "" {
-		protocolConfig, ok := rootConfig.Protocols[constant.DefaultProtocol]
+		protocolConfig, ok := rc.Protocols[constant.DefaultProtocol]
 		if ok {
 			port = protocolConfig.Port
 		} else {

config/provider_config.go

@@ -187,7 +187,7 @@ func (c *ProviderConfig) Load() {
 			serviceConfig = NewServiceConfigBuilder().Build()
 			// use interface name defined by pb
 			serviceConfig.Interface = supportPBPackagerNameService.XXX_InterfaceName()
-			if err := serviceConfig.Init(rootConfig); err != nil {
+			if err := serviceConfig.Init(GetRootConfig()); err != nil {
 				logger.Errorf("Service with registeredTypeName = %s init failed with error = %#v", registeredTypeName, err)
 			}
 			serviceConfig.adaptiveService = c.AdaptiveService

config/root_config.go

@@ -64,7 +64,8 @@ type RootConfig struct {
 }
 
 func SetRootConfig(r RootConfig) {
-	rootConfig = &r
+	rc := r
+	setRootConfigInternal(&rc)
 }
 
 // Prefix dubbo
@@ -73,37 +74,41 @@ func (rc *RootConfig) Prefix() string {
 }
 
 func GetRootConfig() *RootConfig {
-	return rootConfig
+	return getRootConfigInternal()
 }
 
 func GetProviderConfig() *ProviderConfig {
-	if err := check(); err == nil && rootConfig.Provider != nil {
-		return rootConfig.Provider
+	rc := GetRootConfig()
+	if err := check(); err == nil && rc.Provider != nil {
+		return rc.Provider
 	}
 	return NewProviderConfigBuilder().Build()
 }
 
 func GetConsumerConfig() *ConsumerConfig {
-	if err := check(); err == nil && rootConfig.Consumer != nil {
-		return rootConfig.Consumer
+	rc := GetRootConfig()
+	if err := check(); err == nil && rc.Consumer != nil {
+		return rc.Consumer
 	}
 	return NewConsumerConfigBuilder().Build()
 }
 
 func GetApplicationConfig() *ApplicationConfig {
-	return rootConfig.Application
+	return GetRootConfig().Application
 }
 
 func GetShutDown() *ShutdownConfig {
-	if err := check(); err == nil && rootConfig.Shutdown != nil {
-		return rootConfig.Shutdown
+	rc := GetRootConfig()
+	if err := check(); err == nil && rc.Shutdown != nil {
+		return rc.Shutdown
 	}
 	return NewShutDownConfigBuilder().Build()
 }
 
 func GetTLSConfig() *TLSConfig {
-	if err := check(); err == nil && rootConfig.TLSConfig != nil {
-		return rootConfig.TLSConfig
+	rc := GetRootConfig()
+	if err := check(); err == nil && rc.TLSConfig != nil {
+		return rc.TLSConfig
 	}
 	return NewTLSConfigBuilder().Build()
 }

config/root_config_test.go

@@ -18,6 +18,8 @@
 package config
 
 import (
+	"fmt"
+	"sync"
 	"testing"
 )
 
@@ -90,3 +92,24 @@ func TestNewRootConfigBuilder(t *testing.T) {
 	config := GetRootConfig()
 	assert.Equal(t, rootConfig, config)
 }
+
+func TestRootConfigConcurrentSetAndGet(t *testing.T) {
+	SetRootConfig(*NewRootConfigBuilder().Build())
+
+	var wg sync.WaitGroup
+	for i := 0; i < 200; i++ {
+		wg.Add(2)
+		go func(idx int) {
+			defer wg.Done()
+			cfg := NewRootConfigBuilder().Build()
+			cfg.Application.Name = fmt.Sprintf("app-%d", idx)
+			SetRootConfig(*cfg)
+		}(i)
+		go func() {
+			defer wg.Done()
+			_ = GetRootConfig()
+		}()
+	}
+	wg.Wait()
+	assert.NotNil(t, GetRootConfig())
+}