This is an automated email from the ASF dual-hosted git repository.
Alanxtl pushed a commit to branch develop
in repository https://gitbox.apache.org/repos/asf/dubbo-go.git
The following commit(s) were added to refs/heads/develop by this push:
new 01e36daca refactor: remove root config compatibility bridge (#3448)
01e36daca is described below
commit 01e36dacadb6ba4009c7ca5c8858a37336f95c77
Author: 翎 <[email protected]>
AuthorDate: Mon Jun 22 12:40:58 2026 +0800
refactor: remove root config compatibility bridge (#3448)
---
compat.go | 794 -----------------------------------------------
compat_test.go | 196 ------------
config/compat_test.go | 339 --------------------
dubbo_test.go | 78 ++---
instance_options_init.go | 3 +-
options.go | 1 -
6 files changed, 25 insertions(+), 1386 deletions(-)
diff --git a/compat.go b/compat.go
deleted file mode 100644
index f786bd543..000000000
--- a/compat.go
+++ /dev/null
@@ -1,794 +0,0 @@
-/*
- * 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 dubbo
-
-import (
- "dubbo.apache.org/dubbo-go/v3/common"
- "dubbo.apache.org/dubbo-go/v3/config"
- "dubbo.apache.org/dubbo-go/v3/global"
-)
-
-func compatRootConfig(c *InstanceOptions) *config.RootConfig {
- if c == nil {
- return nil
- }
- proCompat := make(map[string]*config.ProtocolConfig)
- for k, v := range c.Protocols {
- proCompat[k] = compatProtocolConfig(v)
- }
-
- regCompat := make(map[string]*config.RegistryConfig)
- for k, v := range c.Registries {
- regCompat[k] = compatRegistryConfig(v)
- }
-
- routeCompat := make([]*config.RouterConfig, 0)
- for _, v := range c.Router {
- routeCompat = append(routeCompat, compatRouterConfig(v))
- }
- tracingCompat := make(map[string]*config.TracingConfig)
- for k, v := range c.Tracing {
- if v == nil {
- tracingCompat[k] = nil
- continue
- }
- tracingCompat[k] = &config.TracingConfig{
- Name: v.Name,
- ServiceName: v.ServiceName,
- Address: v.Address,
- UseAgent: v.UseAgent,
- }
- }
- return &config.RootConfig{
- Application: compatApplicationConfig(c.Application),
- Protocols: proCompat,
- Registries: regCompat,
- ConfigCenter: compatCenterConfig(c.ConfigCenter),
- MetadataReport:
compatMetadataReportConfig(c.MetadataReport),
- Provider: compatProviderConfig(c.Provider),
- Consumer: compatConsumerConfig(c.Consumer),
- Metrics: compatMetricConfig(c.Metrics),
- Tracing: tracingCompat,
- Otel: compatOtelConfig(c.Otel),
- Logger: compatLoggerConfig(c.Logger),
- Shutdown: compatShutdownConfig(c.Shutdown),
- Router: routeCompat,
- EventDispatcherType: c.EventDispatcherType,
- CacheFile: c.CacheFile,
- Custom: compatCustomConfig(c.Custom),
- Profiles: compatProfilesConfig(c.Profiles),
- TLSConfig: compatTLSConfig(c.TLSConfig),
- }
-}
-
-func compatApplicationConfig(c *global.ApplicationConfig)
*config.ApplicationConfig {
- if c == nil {
- return nil
- }
- return &config.ApplicationConfig{
- Organization: c.Organization,
- Name: c.Name,
- Module: c.Module,
- Group: c.Group,
- Version: c.Version,
- Owner: c.Owner,
- Environment: c.Environment,
- MetadataType: c.MetadataType,
- Tag: c.Tag,
- MetadataServicePort: c.MetadataServicePort,
- MetadataServiceProtocol: c.MetadataServiceProtocol,
- }
-}
-
-func compatProtocolConfig(c *global.ProtocolConfig) *config.ProtocolConfig {
- if c == nil {
- return nil
- }
- return &config.ProtocolConfig{
- Name: c.Name,
- Ip: c.Ip,
- Port: c.Port,
- Params: c.Params,
- TripleConfig: compatTripleConfig(c.TripleConfig),
- MaxServerSendMsgSize: c.MaxServerSendMsgSize,
- MaxServerRecvMsgSize: c.MaxServerRecvMsgSize,
- }
-}
-
-// just for compat
-func compatTripleConfig(c *global.TripleConfig) *config.TripleConfig {
- if c == nil {
- return nil
- }
- return &config.TripleConfig{
- MaxServerSendMsgSize: c.MaxServerSendMsgSize,
- MaxServerRecvMsgSize: c.MaxServerRecvMsgSize,
- Http3: compatHttp3Config(c.Http3),
-
- KeepAliveInterval: c.KeepAliveInterval,
- KeepAliveTimeout: c.KeepAliveTimeout,
- }
-}
-
-// just for compat
-func compatHttp3Config(c *global.Http3Config) *config.Http3Config {
- if c == nil {
- return nil
- }
- return &config.Http3Config{
- Enable: c.Enable,
- Negotiation: c.Negotiation,
- }
-}
-
-func compatRegistryConfig(c *global.RegistryConfig) *config.RegistryConfig {
- if c == nil {
- return nil
- }
- return &config.RegistryConfig{
- Protocol: c.Protocol,
- Timeout: c.Timeout,
- Group: c.Group,
- Namespace: c.Namespace,
- TTL: c.TTL,
- Address: c.Address,
- Username: c.Username,
- Password: c.Password,
- Simplified: c.Simplified,
- Preferred: c.Preferred,
- Zone: c.Zone,
- Weight: c.Weight,
- Params: c.Params,
- RegistryType: c.RegistryType,
- UseAsMetaReport: c.UseAsMetaReport,
- UseAsConfigCenter: c.UseAsConfigCenter,
- }
-}
-
-func compatCenterConfig(c *global.CenterConfig) *config.CenterConfig {
- if c == nil {
- return nil
- }
- return &config.CenterConfig{
- Protocol: c.Protocol,
- Address: c.Address,
- DataId: c.DataId,
- Cluster: c.Cluster,
- Group: c.Group,
- Username: c.Username,
- Password: c.Password,
- Namespace: c.Namespace,
- AppID: c.AppID,
- Timeout: c.Timeout,
- Params: c.Params,
- FileExtension: c.FileExtension,
- }
-}
-
-func compatMetadataReportConfig(c *global.MetadataReportConfig)
*config.MetadataReportConfig {
- if c == nil {
- return nil
- }
- return &config.MetadataReportConfig{
- Protocol: c.Protocol,
- Address: c.Address,
- Username: c.Username,
- Password: c.Password,
- Timeout: c.Timeout,
- Group: c.Group,
- Namespace: c.Namespace,
- Params: c.Params,
- }
-}
-
-func compatProviderConfig(c *global.ProviderConfig) *config.ProviderConfig {
- if c == nil {
- return nil
- }
- services := make(map[string]*config.ServiceConfig)
- for key, svc := range c.Services {
- services[key] = compatServiceConfig(svc)
- }
- return &config.ProviderConfig{
- Filter: c.Filter,
- Register: c.Register,
- RegistryIDs: c.RegistryIDs,
- ProtocolIDs: c.ProtocolIDs,
- TracingKey: c.TracingKey,
- Services: services,
- ProxyFactory: c.ProxyFactory,
- FilterConf: c.FilterConf,
- ConfigType: c.ConfigType,
- AdaptiveService: c.AdaptiveService,
- AdaptiveServiceVerbose: c.AdaptiveServiceVerbose,
- }
-}
-
-func compatServiceConfig(c *global.ServiceConfig) *config.ServiceConfig {
- if c == nil {
- return nil
- }
- methods := make([]*config.MethodConfig, len(c.Methods))
- for i, method := range c.Methods {
- methods[i] = compatMethodConfig(method)
- }
- protocols := make(map[string]*config.ProtocolConfig)
- for key, pro := range c.RCProtocolsMap {
- protocols[key] = compatProtocolConfig(pro)
- }
- registries := make(map[string]*config.RegistryConfig)
- for key, reg := range c.RCRegistriesMap {
- registries[key] = compatRegistryConfig(reg)
- }
- return &config.ServiceConfig{
- Filter: c.Filter,
- ProtocolIDs: c.ProtocolIDs,
- Interface: c.Interface,
- RegistryIDs: c.RegistryIDs,
- Cluster: c.Cluster,
- Loadbalance: c.Loadbalance,
- Group: c.Group,
- Version: c.Version,
- Methods: methods,
- Warmup: c.Warmup,
- Retries: c.Retries,
- Serialization: c.Serialization,
- Params: c.Params,
- Token: c.Token,
- AccessLog: c.AccessLog,
- TpsLimiter: c.TpsLimiter,
- TpsLimitInterval: c.TpsLimitInterval,
- TpsLimitRate: c.TpsLimitRate,
- TpsLimitStrategy: c.TpsLimitStrategy,
- TpsLimitRejectedHandler: c.TpsLimitRejectedHandler,
- ExecuteLimit: c.ExecuteLimit,
- ExecuteLimitRejectedHandler: c.ExecuteLimitRejectedHandler,
- Auth: c.Auth,
- NotRegister: c.NotRegister,
- ParamSign: c.ParamSign,
- Tag: c.Tag,
- TracingKey: c.TracingKey,
- RCProtocolsMap: protocols,
- RCRegistriesMap: registries,
- ProxyFactoryKey: c.ProxyFactoryKey,
- }
-}
-
-func compatMethodConfig(c *global.MethodConfig) *config.MethodConfig {
- if c == nil {
- return nil
- }
- return &config.MethodConfig{
- InterfaceId: c.InterfaceId,
- InterfaceName: c.InterfaceName,
- Name: c.Name,
- Retries: c.Retries,
- LoadBalance: c.LoadBalance,
- Weight: c.Weight,
- TpsLimitInterval: c.TpsLimitInterval,
- TpsLimitRate: c.TpsLimitRate,
- TpsLimitStrategy: c.TpsLimitStrategy,
- ExecuteLimit: c.ExecuteLimit,
- ExecuteLimitRejectedHandler: c.ExecuteLimitRejectedHandler,
- Sticky: c.Sticky,
- RequestTimeout: c.RequestTimeout,
- }
-}
-
-func compatConsumerConfig(c *global.ConsumerConfig) *config.ConsumerConfig {
- if c == nil {
- return nil
- }
- return &config.ConsumerConfig{
- Filter: c.Filter,
- RegistryIDs: c.RegistryIDs,
- Protocol: c.Protocol,
- RequestTimeout: c.RequestTimeout,
- ProxyFactory: c.ProxyFactory,
- Check: c.Check,
- AdaptiveService: c.AdaptiveService,
- TracingKey: c.TracingKey,
- FilterConf: c.FilterConf,
- MaxWaitTimeForServiceDiscovery:
c.MaxWaitTimeForServiceDiscovery,
- MeshEnabled: c.MeshEnabled,
- References: compatReferences(c.References),
- }
-}
-
-func compatReferences(c map[string]*global.ReferenceConfig)
map[string]*config.ReferenceConfig {
- refs := make(map[string]*config.ReferenceConfig, len(c))
- for name, ref := range c {
- refs[name] = &config.ReferenceConfig{
- InterfaceName: ref.InterfaceName,
- Check: ref.Check,
- URL: ref.URL,
- Filter: ref.Filter,
- Protocol: ref.Protocol,
- RegistryIDs: ref.RegistryIDs,
- Cluster: ref.Cluster,
- Loadbalance: ref.Loadbalance,
- Retries: ref.Retries,
- Group: ref.Group,
- Version: ref.Version,
- Serialization: ref.Serialization,
- ProvidedBy: ref.ProvidedBy,
- MethodsConfig: compatMethod(ref.MethodsConfig),
- ProtocolClientConfig:
compatProtocolClientConfig(ref.ProtocolClientConfig),
- Async: ref.Async,
- Params: ref.Params,
- Generic: ref.Generic,
- Sticky: ref.Sticky,
- RequestTimeout: ref.RequestTimeout,
- ForceTag: ref.ForceTag,
- TracingKey: ref.TracingKey,
- MeshProviderPort: ref.MeshProviderPort,
- }
- }
- return refs
-}
-
-// TODO: merge compatGlobalMethod() and compatGlobalMethodConfig
-func compatMethod(m []*global.MethodConfig) []*config.MethodConfig {
- methods := make([]*config.MethodConfig, 0, len(m))
- for _, method := range m {
- methods = append(methods, &config.MethodConfig{
- InterfaceId: method.InterfaceId,
- InterfaceName: method.InterfaceName,
- Name: method.Name,
- Retries: method.Retries,
- LoadBalance: method.LoadBalance,
- Weight: method.Weight,
- TpsLimitInterval: method.TpsLimitInterval,
- TpsLimitRate: method.TpsLimitRate,
- TpsLimitStrategy: method.TpsLimitStrategy,
- ExecuteLimit: method.ExecuteLimit,
- ExecuteLimitRejectedHandler:
method.ExecuteLimitRejectedHandler,
- Sticky: method.Sticky,
- RequestTimeout: method.RequestTimeout,
- })
- }
- return methods
-}
-
-// just for compat
-func compatProtocolClientConfig(c *global.ClientProtocolConfig)
*config.ClientProtocolConfig {
- if c == nil {
- return nil
- }
- return &config.ClientProtocolConfig{
- Name: c.Name,
- TripleConfig: compatTripleConfig(c.TripleConfig),
- }
-}
-
-func compatMetricConfig(c *global.MetricsConfig) *config.MetricsConfig {
- if c == nil {
- return nil
- }
- return &config.MetricsConfig{
- Enable: c.Enable,
- Port: c.Port,
- Path: c.Path,
- Prometheus: compatMetricPrometheusConfig(c.Prometheus),
- Aggregation:
compatMetricAggregationConfig(c.Aggregation),
- Protocol: c.Protocol,
- EnableMetadata: c.EnableMetadata,
- EnableRegistry: c.EnableRegistry,
- EnableConfigCenter: c.EnableConfigCenter,
- Probe: compatMetricProbeConfig(c.Probe),
- }
-}
-
-func compatMetricProbeConfig(c *global.ProbeConfig) *config.ProbeConfig {
- if c == nil {
- return nil
- }
- return &config.ProbeConfig{
- Enabled: c.Enabled,
- Port: c.Port,
- LivenessPath: c.LivenessPath,
- ReadinessPath: c.ReadinessPath,
- StartupPath: c.StartupPath,
- UseInternalState: c.UseInternalState,
- }
-}
-
-func compatOtelConfig(c *global.OtelConfig) *config.OtelConfig {
- if c == nil {
- return nil
- }
- return &config.OtelConfig{
- TraceConfig: &config.OtelTraceConfig{
- Enable: c.TracingConfig.Enable,
- Exporter: c.TracingConfig.Exporter,
- Endpoint: c.TracingConfig.Endpoint,
- Propagator: c.TracingConfig.Propagator,
- SampleMode: c.TracingConfig.SampleMode,
- SampleRatio: c.TracingConfig.SampleRatio,
- Insecure: c.TracingConfig.Insecure,
- },
- }
-}
-
-// compatTraceIntegrationConfig converts global.TraceIntegrationConfig to
config.TraceIntegrationConfig
-func compatTraceIntegrationConfig(c *global.TraceIntegrationConfig)
*config.TraceIntegrationConfig {
- if c == nil {
- return nil
- }
- return &config.TraceIntegrationConfig{
- Enabled: c.Enabled,
- RecordErrorToSpan: c.RecordErrorToSpan,
- }
-}
-
-func compatLoggerConfig(c *global.LoggerConfig) *config.LoggerConfig {
- if c == nil {
- return nil
- }
- return &config.LoggerConfig{
- Driver: c.Driver,
- Level: c.Level,
- Format: c.Format,
- Appender: c.Appender,
- File: compatFile(c.File),
- TraceIntegration:
compatTraceIntegrationConfig(c.TraceIntegration),
- }
-}
-
-func compatFile(c *global.File) *config.File {
- if c == nil {
- return nil
- }
- return &config.File{
- Name: c.Name,
- MaxSize: c.MaxSize,
- MaxBackups: c.MaxBackups,
- MaxAge: c.MaxAge,
- Compress: c.Compress,
- }
-}
-
-func compatShutdownConfig(c *global.ShutdownConfig) *config.ShutdownConfig {
- if c == nil {
- return nil
- }
- return c.Clone()
-}
-
-func compatRouterConfig(c *global.RouterConfig) *config.RouterConfig {
- if c == nil {
- return nil
- }
- return &config.RouterConfig{
- Scope: c.Scope,
- Key: c.Key,
- Force: c.Force,
- Runtime: c.Runtime,
- Enabled: c.Enabled,
- Valid: c.Valid,
- Priority: c.Priority,
- Conditions: c.Conditions,
- Tags: compatTags(c.Tags),
- ScriptType: c.ScriptType,
- Script: c.Script,
- }
-
-}
-
-func compatTags(c []global.Tag) []config.Tag {
- if c == nil {
- return nil
- }
- // deep copy
- tags := make([]config.Tag, len(c))
-
- for i := range c {
- tags[i].Name = c[i].Name
- if c[i].Match != nil {
- tags[i].Match = make([]*common.ParamMatch,
len(c[i].Match))
- for j := range c[i].Match {
- if c[i].Match[j] != nil {
- pm := *c[i].Match[j]
- tags[i].Match[j] = &pm
- }
- }
- }
-
- if c[i].Addresses != nil {
- tags[i].Addresses = make([]string, len(c[i].Addresses))
- copy(tags[i].Addresses, c[i].Addresses)
- }
- }
-
- return tags
-}
-
-func compatCustomConfig(c *global.CustomConfig) *config.CustomConfig {
- if c == nil {
- return nil
- }
- return &config.CustomConfig{
- ConfigMap: c.ConfigMap,
- }
-}
-
-func compatProfilesConfig(c *global.ProfilesConfig) *config.ProfilesConfig {
- if c == nil {
- return nil
- }
- return &config.ProfilesConfig{
- Active: c.Active,
- }
-}
-
-func compatMetricAggregationConfig(a *global.AggregateConfig)
*config.AggregateConfig {
- if a == nil {
- return nil
- }
- return &config.AggregateConfig{
- Enabled: a.Enabled,
- BucketNum: a.BucketNum,
- TimeWindowSeconds: a.TimeWindowSeconds,
- }
-}
-
-func compatMetricPrometheusConfig(c *global.PrometheusConfig)
*config.PrometheusConfig {
- if c == nil {
- return nil
- }
- return &config.PrometheusConfig{
- Exporter: compatMetricPrometheusExporter(c.Exporter),
- Pushgateway: compatMetricPrometheusGateway(c.Pushgateway),
- }
-}
-
-func compatMetricPrometheusExporter(e *global.Exporter) *config.Exporter {
- if e == nil {
- return nil
- }
- return &config.Exporter{
- Enabled: e.Enabled,
- }
-}
-
-func compatMetricPrometheusGateway(g *global.PushgatewayConfig)
*config.PushgatewayConfig {
- if g == nil {
- return nil
- }
- return &config.PushgatewayConfig{
- Enabled: g.Enabled,
- BaseUrl: g.BaseUrl,
- Job: g.Job,
- Username: g.Username,
- Password: g.Password,
- PushInterval: g.PushInterval,
- }
-}
-
-func setCompatRootConfig(rc *config.RootConfig) {
- config.SetRootConfig(*rc)
-}
-
-func CompatGlobalProtocolConfig(c *config.ProtocolConfig)
*global.ProtocolConfig {
- if c == nil {
- return nil
- }
- return &global.ProtocolConfig{
- Name: c.Name,
- Ip: c.Ip,
- Port: c.Port,
- Params: c.Params,
- TripleConfig: compatGlobalTripleConfig(c.TripleConfig),
- MaxServerSendMsgSize: c.MaxServerSendMsgSize,
- MaxServerRecvMsgSize: c.MaxServerRecvMsgSize,
- }
-}
-
-func CompatGlobalProtocolConfigMap(m map[string]*config.ProtocolConfig)
map[string]*global.ProtocolConfig {
- if m == nil {
- return nil
- }
- protocols := make(map[string]*global.ProtocolConfig, len(m))
- for k, v := range m {
- protocols[k] = CompatGlobalProtocolConfig(v)
- }
- return protocols
-}
-
-// just for compat
-func compatGlobalTripleConfig(c *config.TripleConfig) *global.TripleConfig {
- if c == nil {
- return nil
- }
- return &global.TripleConfig{
- KeepAliveInterval: c.KeepAliveInterval,
- KeepAliveTimeout: c.KeepAliveTimeout,
- Http3: compatGlobalHttp3Config(c.Http3),
-
- MaxServerSendMsgSize: c.MaxServerSendMsgSize,
- MaxServerRecvMsgSize: c.MaxServerRecvMsgSize,
- }
-}
-
-// just for compat
-func compatGlobalHttp3Config(c *config.Http3Config) *global.Http3Config {
- if c == nil {
- return nil
- }
- return &global.Http3Config{
- Enable: c.Enable,
- Negotiation: c.Negotiation,
- }
-}
-
-func compatGlobalRegistryConfig(c *config.RegistryConfig)
*global.RegistryConfig {
- if c == nil {
- return nil
- }
- return &global.RegistryConfig{
- Protocol: c.Protocol,
- Timeout: c.Timeout,
- Group: c.Group,
- Namespace: c.Namespace,
- TTL: c.TTL,
- Address: c.Address,
- Username: c.Username,
- Password: c.Password,
- Simplified: c.Simplified,
- Preferred: c.Preferred,
- Zone: c.Zone,
- Weight: c.Weight,
- Params: c.Params,
- RegistryType: c.RegistryType,
- UseAsMetaReport: c.UseAsMetaReport,
- UseAsConfigCenter: c.UseAsConfigCenter,
- }
-}
-
-func CompatGlobalServiceConfig(c *config.ServiceConfig) *global.ServiceConfig {
- if c == nil {
- return nil
- }
- methods := make([]*global.MethodConfig, len(c.Methods))
- for i, method := range c.Methods {
- methods[i] = compatGlobalMethodConfig(method)
- }
- protocols := make(map[string]*global.ProtocolConfig)
- for key, pro := range c.RCProtocolsMap {
- protocols[key] = CompatGlobalProtocolConfig(pro)
- }
- registries := make(map[string]*global.RegistryConfig)
- for key, reg := range c.RCRegistriesMap {
- registries[key] = compatGlobalRegistryConfig(reg)
- }
- return &global.ServiceConfig{
- Filter: c.Filter,
- ProtocolIDs: c.ProtocolIDs,
- Interface: c.Interface,
- RegistryIDs: c.RegistryIDs,
- Cluster: c.Cluster,
- Loadbalance: c.Loadbalance,
- Group: c.Group,
- Version: c.Version,
- Methods: methods,
- Warmup: c.Warmup,
- Retries: c.Retries,
- Serialization: c.Serialization,
- Params: c.Params,
- Token: c.Token,
- AccessLog: c.AccessLog,
- TpsLimiter: c.TpsLimiter,
- TpsLimitInterval: c.TpsLimitInterval,
- TpsLimitRate: c.TpsLimitRate,
- TpsLimitStrategy: c.TpsLimitStrategy,
- TpsLimitRejectedHandler: c.TpsLimitRejectedHandler,
- ExecuteLimit: c.ExecuteLimit,
- ExecuteLimitRejectedHandler: c.ExecuteLimitRejectedHandler,
- Auth: c.Auth,
- NotRegister: c.NotRegister,
- ParamSign: c.ParamSign,
- Tag: c.Tag,
- TracingKey: c.TracingKey,
- RCProtocolsMap: protocols,
- RCRegistriesMap: registries,
- ProxyFactoryKey: c.ProxyFactoryKey,
- }
-}
-
-func compatGlobalMethodConfig(c *config.MethodConfig) *global.MethodConfig {
- if c == nil {
- return nil
- }
- return &global.MethodConfig{
- InterfaceId: c.InterfaceId,
- InterfaceName: c.InterfaceName,
- Name: c.Name,
- Retries: c.Retries,
- LoadBalance: c.LoadBalance,
- Weight: c.Weight,
- TpsLimitInterval: c.TpsLimitInterval,
- TpsLimitRate: c.TpsLimitRate,
- TpsLimitStrategy: c.TpsLimitStrategy,
- ExecuteLimit: c.ExecuteLimit,
- ExecuteLimitRejectedHandler: c.ExecuteLimitRejectedHandler,
- Sticky: c.Sticky,
- RequestTimeout: c.RequestTimeout,
- }
-}
-
-// compatGlobalTraceIntegrationConfig converts config.TraceIntegrationConfig
to global.TraceIntegrationConfig
-func compatGlobalTraceIntegrationConfig(c *config.TraceIntegrationConfig)
*global.TraceIntegrationConfig {
- if c == nil {
- return nil
- }
- return &global.TraceIntegrationConfig{
- Enabled: c.Enabled,
- RecordErrorToSpan: c.RecordErrorToSpan,
- }
-}
-
-func compatGlobalLoggerConfig(c *config.LoggerConfig) *global.LoggerConfig {
- if c == nil {
- return nil
- }
- return &global.LoggerConfig{
- Driver: c.Driver,
- Level: c.Level,
- Format: c.Format,
- Appender: c.Appender,
- File: compatGlobalFile(c.File),
- TraceIntegration:
compatGlobalTraceIntegrationConfig(c.TraceIntegration),
- }
-}
-
-func compatGlobalFile(c *config.File) *global.File {
- if c == nil {
- return nil
- }
- return &global.File{
- Name: c.Name,
- MaxSize: c.MaxSize,
- MaxBackups: c.MaxBackups,
- MaxAge: c.MaxAge,
- Compress: c.Compress,
- }
-}
-
-func compatTLSConfig(c *global.TLSConfig) *config.TLSConfig {
- if c == nil {
- return nil
- }
- return &config.TLSConfig{
- CACertFile: c.CACertFile,
- TLSCertFile: c.TLSCertFile,
- TLSKeyFile: c.TLSKeyFile,
- TLSServerName: c.TLSServerName,
- }
-}
-
-func CompatGlobalTLSConfig(c *config.TLSConfig) *global.TLSConfig {
- if c == nil {
- return nil
- }
- return &global.TLSConfig{
- CACertFile: c.CACertFile,
- TLSCertFile: c.TLSCertFile,
- TLSKeyFile: c.TLSKeyFile,
- TLSServerName: c.TLSServerName,
- }
-}
diff --git a/compat_test.go b/compat_test.go
deleted file mode 100644
index 20aba88a4..000000000
--- a/compat_test.go
+++ /dev/null
@@ -1,196 +0,0 @@
-/*
- * 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 dubbo
-
-import (
- "testing"
-)
-
-import (
- "github.com/stretchr/testify/assert"
-)
-
-import (
- "dubbo.apache.org/dubbo-go/v3/config"
- "dubbo.apache.org/dubbo-go/v3/global"
-)
-
-// TestCompatLoggerConfigWithTraceIntegration tests the conversion functions
for LoggerConfig with TraceIntegration
-func TestCompatLoggerConfigWithTraceIntegration(t *testing.T) {
- t.Run("global_to_config_with_trace_integration", func(t *testing.T) {
- enabled := true
- recordError := false
- globalCfg := &global.LoggerConfig{
- Driver: "zap",
- Level: "info",
- Format: "json",
- Appender: "console",
- TraceIntegration: &global.TraceIntegrationConfig{
- Enabled: &enabled,
- RecordErrorToSpan: &recordError,
- },
- }
-
- configCfg := compatLoggerConfig(globalCfg)
-
- assert.NotNil(t, configCfg)
- assert.Equal(t, globalCfg.Driver, configCfg.Driver)
- assert.Equal(t, globalCfg.Level, configCfg.Level)
- assert.Equal(t, globalCfg.Format, configCfg.Format)
- assert.Equal(t, globalCfg.Appender, configCfg.Appender)
- assert.NotNil(t, configCfg.TraceIntegration)
- assert.Equal(t, *globalCfg.TraceIntegration.Enabled,
*configCfg.TraceIntegration.Enabled)
- assert.Equal(t, *globalCfg.TraceIntegration.RecordErrorToSpan,
*configCfg.TraceIntegration.RecordErrorToSpan)
- })
-
- t.Run("global_to_config_with_nil_trace_integration", func(t *testing.T)
{
- globalCfg := &global.LoggerConfig{
- Driver: "zap",
- Level: "info",
- TraceIntegration: nil,
- }
-
- configCfg := compatLoggerConfig(globalCfg)
-
- assert.NotNil(t, configCfg)
- assert.Nil(t, configCfg.TraceIntegration)
- })
-
- t.Run("global_to_config_nil", func(t *testing.T) {
- var globalCfg *global.LoggerConfig
- configCfg := compatLoggerConfig(globalCfg)
- assert.Nil(t, configCfg)
- })
-
- t.Run("config_to_global_with_trace_integration", func(t *testing.T) {
- enabled := true
- recordError := false
- configCfg := &config.LoggerConfig{
- Driver: "zap",
- Level: "info",
- Format: "json",
- Appender: "console",
- TraceIntegration: &config.TraceIntegrationConfig{
- Enabled: &enabled,
- RecordErrorToSpan: &recordError,
- },
- }
-
- globalCfg := compatGlobalLoggerConfig(configCfg)
-
- assert.NotNil(t, globalCfg)
- assert.Equal(t, configCfg.Driver, globalCfg.Driver)
- assert.Equal(t, configCfg.Level, globalCfg.Level)
- assert.Equal(t, configCfg.Format, globalCfg.Format)
- assert.Equal(t, configCfg.Appender, globalCfg.Appender)
- assert.NotNil(t, globalCfg.TraceIntegration)
- assert.Equal(t, *configCfg.TraceIntegration.Enabled,
*globalCfg.TraceIntegration.Enabled)
- assert.Equal(t, *configCfg.TraceIntegration.RecordErrorToSpan,
*globalCfg.TraceIntegration.RecordErrorToSpan)
- })
-
- t.Run("config_to_global_with_nil_trace_integration", func(t *testing.T)
{
- configCfg := &config.LoggerConfig{
- Driver: "zap",
- Level: "info",
- TraceIntegration: nil,
- }
-
- globalCfg := compatGlobalLoggerConfig(configCfg)
-
- assert.NotNil(t, globalCfg)
- assert.Nil(t, globalCfg.TraceIntegration)
- })
-
- t.Run("config_to_global_nil", func(t *testing.T) {
- var configCfg *config.LoggerConfig
- globalCfg := compatGlobalLoggerConfig(configCfg)
- assert.Nil(t, globalCfg)
- })
-
- t.Run("round_trip_conversion", func(t *testing.T) {
- enabled := true
- recordError := false
- originalGlobal := &global.LoggerConfig{
- Driver: "zap",
- Level: "debug",
- TraceIntegration: &global.TraceIntegrationConfig{
- Enabled: &enabled,
- RecordErrorToSpan: &recordError,
- },
- }
-
- // global -> config
- intermediateConfig := compatLoggerConfig(originalGlobal)
- assert.NotNil(t, intermediateConfig.TraceIntegration)
-
- // config -> global
- convertedGlobal := compatGlobalLoggerConfig(intermediateConfig)
- assert.NotNil(t, convertedGlobal.TraceIntegration)
-
- // Verify values are preserved
- assert.Equal(t, originalGlobal.Driver, convertedGlobal.Driver)
- assert.Equal(t, originalGlobal.Level, convertedGlobal.Level)
- assert.Equal(t, *originalGlobal.TraceIntegration.Enabled,
*convertedGlobal.TraceIntegration.Enabled)
- assert.Equal(t,
*originalGlobal.TraceIntegration.RecordErrorToSpan,
*convertedGlobal.TraceIntegration.RecordErrorToSpan)
- })
-}
-
-// TestCompatTraceIntegrationConfig tests the helper conversion functions
-func TestCompatTraceIntegrationConfig(t *testing.T) {
- t.Run("compatTraceIntegrationConfig_with_values", func(t *testing.T) {
- enabled := true
- recordError := false
- globalCfg := &global.TraceIntegrationConfig{
- Enabled: &enabled,
- RecordErrorToSpan: &recordError,
- }
-
- configCfg := compatTraceIntegrationConfig(globalCfg)
-
- assert.NotNil(t, configCfg)
- assert.Equal(t, *globalCfg.Enabled, *configCfg.Enabled)
- assert.Equal(t, *globalCfg.RecordErrorToSpan,
*configCfg.RecordErrorToSpan)
- })
-
- t.Run("compatTraceIntegrationConfig_nil", func(t *testing.T) {
- var globalCfg *global.TraceIntegrationConfig
- configCfg := compatTraceIntegrationConfig(globalCfg)
- assert.Nil(t, configCfg)
- })
-
- t.Run("compatGlobalTraceIntegrationConfig_with_values", func(t
*testing.T) {
- enabled := true
- recordError := false
- configCfg := &config.TraceIntegrationConfig{
- Enabled: &enabled,
- RecordErrorToSpan: &recordError,
- }
-
- globalCfg := compatGlobalTraceIntegrationConfig(configCfg)
-
- assert.NotNil(t, globalCfg)
- assert.Equal(t, *configCfg.Enabled, *globalCfg.Enabled)
- assert.Equal(t, *configCfg.RecordErrorToSpan,
*globalCfg.RecordErrorToSpan)
- })
-
- t.Run("compatGlobalTraceIntegrationConfig_nil", func(t *testing.T) {
- var configCfg *config.TraceIntegrationConfig
- globalCfg := compatGlobalTraceIntegrationConfig(configCfg)
- assert.Nil(t, globalCfg)
- })
-}
diff --git a/config/compat_test.go b/config/compat_test.go
deleted file mode 100644
index f733af850..000000000
--- a/config/compat_test.go
+++ /dev/null
@@ -1,339 +0,0 @@
-/*
- * 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 config_test
-
-import (
- "testing"
-)
-
-import (
- "github.com/stretchr/testify/assert"
- "github.com/stretchr/testify/require"
-)
-
-import (
- dubbo "dubbo.apache.org/dubbo-go/v3"
- "dubbo.apache.org/dubbo-go/v3/config"
- "dubbo.apache.org/dubbo-go/v3/global"
-)
-
-const (
- compatProtoID = "tri-compat"
- compatRegID = "nacos-compat"
- compatSvcID = "com.example.CompatProviderService"
- compatRefID = "com.example.CompatReferenceService"
-)
-
-func TestCompatApp(t *testing.T) {
- root := compatRoot(t)
-
- require.NotNil(t, root.Application)
- assert.Equal(t, "compat-app", root.Application.Name)
- assert.Equal(t, "compat-group", root.Application.Group)
- assert.Equal(t, "1.0.0", root.Application.Version)
- assert.Equal(t, "gray", root.Application.Tag)
-}
-
-func TestCompatProto(t *testing.T) {
- root := compatRoot(t)
-
- require.Len(t, root.Protocols, 1)
- protocolCfg := root.Protocols[compatProtoID]
- require.NotNil(t, protocolCfg)
- assert.Equal(t, "tri", protocolCfg.Name)
- assert.Equal(t, "127.0.0.1", protocolCfg.Ip)
- assert.Equal(t, "20000", protocolCfg.Port)
- assert.Equal(t, "8mib", protocolCfg.MaxServerSendMsgSize)
- assert.Equal(t, "6mib", protocolCfg.MaxServerRecvMsgSize)
- require.NotNil(t, protocolCfg.TripleConfig)
- assert.Equal(t, "30s", protocolCfg.TripleConfig.KeepAliveInterval)
- assert.Equal(t, "10s", protocolCfg.TripleConfig.KeepAliveTimeout)
- require.NotNil(t, protocolCfg.TripleConfig.Http3)
- assert.True(t, protocolCfg.TripleConfig.Http3.Enable)
- assert.False(t, protocolCfg.TripleConfig.Http3.Negotiation)
-}
-
-func TestCompatRegistry(t *testing.T) {
- root := compatRoot(t)
-
- require.Len(t, root.Registries, 1)
- registryCfg := root.Registries[compatRegID]
- require.NotNil(t, registryCfg)
- assert.Equal(t, "nacos", registryCfg.Protocol)
- assert.Equal(t, "127.0.0.1:8848", registryCfg.Address)
- assert.Equal(t, "compat-ns", registryCfg.Namespace)
- assert.Equal(t, "true", registryCfg.UseAsConfigCenter)
-}
-
-func TestCompatProvider(t *testing.T) {
- root := compatRoot(t)
-
- require.NotNil(t, root.Provider)
- assert.Equal(t, "echo", root.Provider.Filter)
- assert.Equal(t, []string{compatRegID}, root.Provider.RegistryIDs)
- assert.Equal(t, []string{compatProtoID}, root.Provider.ProtocolIDs)
- assert.Contains(t, root.Provider.Services, compatSvcID)
- providerSvc := root.Provider.Services[compatSvcID]
- require.NotNil(t, providerSvc)
- assert.Equal(t, compatSvcID, providerSvc.Interface)
- assert.Equal(t, "provider-group", providerSvc.Group)
- assert.Equal(t, "provider-v1", providerSvc.Version)
- assert.Equal(t, "failover", providerSvc.Cluster)
- assert.Equal(t, "random", providerSvc.Loadbalance)
- require.Len(t, providerSvc.Methods, 1)
- assert.Equal(t, "SayHello", providerSvc.Methods[0].Name)
- assert.Equal(t, "2s", providerSvc.Methods[0].RequestTimeout)
-}
-
-func TestCompatConsumer(t *testing.T) {
- root := compatRoot(t)
-
- require.NotNil(t, root.Consumer)
- assert.Equal(t, "cshutdown", root.Consumer.Filter)
- assert.Equal(t, "tri", root.Consumer.Protocol)
- assert.Equal(t, "5s", root.Consumer.RequestTimeout)
- assert.Contains(t, root.Consumer.References, compatRefID)
- refCfg := root.Consumer.References[compatRefID]
- require.NotNil(t, refCfg)
- assert.Equal(t, compatRefID, refCfg.InterfaceName)
- assert.Equal(t, "tri://127.0.0.1:20000", refCfg.URL)
- assert.Equal(t, "ref-group", refCfg.Group)
- assert.Equal(t, "ref-v1", refCfg.Version)
- assert.Equal(t, "tri", refCfg.Protocol)
- require.Len(t, refCfg.MethodsConfig, 1)
- assert.Equal(t, "Query", refCfg.MethodsConfig[0].Name)
- assert.Equal(t, "1s", refCfg.MethodsConfig[0].RequestTimeout)
-}
-
-func TestCompatMetricsOtel(t *testing.T) {
- root := compatRoot(t)
-
- require.NotNil(t, root.Metrics)
- require.NotNil(t, root.Metrics.Enable)
- assert.True(t, *root.Metrics.Enable)
- assert.Equal(t, "prometheus", root.Metrics.Protocol)
- require.NotNil(t, root.Metrics.Probe)
- assert.Equal(t, "22333", root.Metrics.Probe.Port)
-
- require.NotNil(t, root.Otel)
- require.NotNil(t, root.Otel.TraceConfig)
- require.NotNil(t, root.Otel.TraceConfig.Enable)
- assert.False(t, *root.Otel.TraceConfig.Enable)
- assert.Equal(t, "stdout", root.Otel.TraceConfig.Exporter)
- assert.Equal(t, "http://127.0.0.1:4318";, root.Otel.TraceConfig.Endpoint)
-}
-
-func TestCompatShutdown(t *testing.T) {
- root := compatRoot(t)
-
- require.NotNil(t, root.Shutdown)
- assert.Equal(t, "60s", root.Shutdown.Timeout)
- assert.Equal(t, "3s", root.Shutdown.StepTimeout)
- assert.Equal(t, "2s", root.Shutdown.ConsumerUpdateWaitTime)
- require.NotNil(t, root.Shutdown.InternalSignal)
- assert.True(t, *root.Shutdown.InternalSignal)
-}
-
-// TestCompatEmptyCollections verifies nil-tolerant behavior
-// for optional sections and empty collections in compat conversion.
-func TestCompatEmptyCollections(t *testing.T) {
- _, err := dubbo.NewInstance(func(opts *dubbo.InstanceOptions) {
- opts.Application.Name = "compat-empty"
- opts.Protocols = compatProtocols("20001")
- opts.Registries = map[string]*global.RegistryConfig{}
- opts.Router = nil
- })
- require.NoError(t, err)
-
- root := config.GetRootConfig()
- require.NotNil(t, root)
- assert.NotNil(t, root.Protocols)
- require.Len(t, root.Protocols, 1)
- assert.NotNil(t, root.Registries)
- assert.Empty(t, root.Registries)
- assert.NotNil(t, root.Router)
- assert.Empty(t, root.Router)
-}
-
-func compatRoot(t *testing.T, opts ...dubbo.InstanceOption) *config.RootConfig
{
- t.Helper()
-
- allOpts := make([]dubbo.InstanceOption, 0, len(opts)+1)
- allOpts = append(allOpts, compatFixture())
- allOpts = append(allOpts, opts...)
-
- _, err := dubbo.NewInstance(allOpts...)
- require.NoError(t, err)
-
- root := config.GetRootConfig()
- require.NotNil(t, root)
- return root
-}
-
-func compatFixture() dubbo.InstanceOption {
- return func(opts *dubbo.InstanceOptions) {
- opts.Application = compatApplication()
- opts.Protocols = compatProtocols("20000")
- opts.Registries = compatRegistries()
- opts.Provider = compatProvider()
- opts.Consumer = compatConsumer()
- opts.Metrics = compatMetrics()
- opts.Otel = compatOtel()
- opts.Shutdown = compatShutdown()
- opts.Router = compatRouter()
- opts.Custom = compatCustom()
- opts.Profiles = compatProfiles()
- }
-}
-
-func compatApplication() *global.ApplicationConfig {
- return &global.ApplicationConfig{
- Name: "compat-app",
- Group: "compat-group",
- Version: "1.0.0",
- Tag: "gray",
- }
-}
-
-func compatProtocols(port string) map[string]*global.ProtocolConfig {
- return map[string]*global.ProtocolConfig{
- compatProtoID: {
- Name: "tri",
- Ip: "127.0.0.1",
- Port: port,
- MaxServerSendMsgSize: "8mib",
- MaxServerRecvMsgSize: "6mib",
- TripleConfig: &global.TripleConfig{
- KeepAliveInterval: "30s",
- KeepAliveTimeout: "10s",
- Http3: &global.Http3Config{
- Enable: true,
- Negotiation: false,
- },
- },
- },
- }
-}
-
-func compatRegistries() map[string]*global.RegistryConfig {
- return map[string]*global.RegistryConfig{
- compatRegID: {
- Protocol: "nacos",
- Address: "127.0.0.1:8848",
- Namespace: "compat-ns",
- UseAsConfigCenter: "true",
- },
- }
-}
-
-func compatProvider() *global.ProviderConfig {
- return &global.ProviderConfig{
- Filter: "echo",
- RegistryIDs: []string{compatRegID},
- ProtocolIDs: []string{compatProtoID},
- Services: map[string]*global.ServiceConfig{
- compatSvcID: {
- Interface: compatSvcID,
- Group: "provider-group",
- Version: "provider-v1",
- Cluster: "failover",
- Loadbalance: "random",
- Methods: []*global.MethodConfig{
- {
- Name: "SayHello",
- RequestTimeout: "2s",
- },
- },
- },
- },
- }
-}
-
-func compatConsumer() *global.ConsumerConfig {
- referenceCheck := true
- return &global.ConsumerConfig{
- Filter: "cshutdown",
- Protocol: "tri",
- RequestTimeout: "5s",
- Check: true,
- References: map[string]*global.ReferenceConfig{
- compatRefID: {
- InterfaceName: compatRefID,
- Check: &referenceCheck,
- URL: "tri://127.0.0.1:20000",
- Protocol: "tri",
- Group: "ref-group",
- Version: "ref-v1",
- MethodsConfig: []*global.MethodConfig{
- {
- Name: "Query",
- RequestTimeout: "1s",
- },
- },
- },
- },
- }
-}
-
-func compatMetrics() *global.MetricsConfig {
- metricEnabled := true
- return &global.MetricsConfig{
- Enable: &metricEnabled,
- Protocol: "prometheus",
- Probe: &global.ProbeConfig{
- Port: "22333",
- },
- }
-}
-
-func compatOtel() *global.OtelConfig {
- traceEnabled := false
- return &global.OtelConfig{
- TracingConfig: &global.OtelTraceConfig{
- Enable: &traceEnabled,
- Exporter: "stdout",
- Endpoint: "http://127.0.0.1:4318";,
- },
- }
-}
-
-func compatShutdown() *global.ShutdownConfig {
- internalSignal := true
- return &global.ShutdownConfig{
- Timeout: "60s",
- StepTimeout: "3s",
- ConsumerUpdateWaitTime: "2s",
- InternalSignal: &internalSignal,
- }
-}
-
-func compatRouter() []*global.RouterConfig {
- return []*global.RouterConfig{}
-}
-
-func compatCustom() *global.CustomConfig {
- return &global.CustomConfig{
- ConfigMap: map[string]any{"k": "v"},
- }
-}
-
-func compatProfiles() *global.ProfilesConfig {
- return &global.ProfilesConfig{
- Active: "test",
- }
-}
diff --git a/dubbo_test.go b/dubbo_test.go
index 6e4f227d4..3c8e123b0 100644
--- a/dubbo_test.go
+++ b/dubbo_test.go
@@ -32,7 +32,6 @@ import (
commonCfg "dubbo.apache.org/dubbo-go/v3/common/config"
"dubbo.apache.org/dubbo-go/v3/common/constant"
"dubbo.apache.org/dubbo-go/v3/common/extension"
- legacyconfig "dubbo.apache.org/dubbo-go/v3/config"
"dubbo.apache.org/dubbo-go/v3/config_center"
"dubbo.apache.org/dubbo-go/v3/global"
"dubbo.apache.org/dubbo-go/v3/registry"
@@ -231,12 +230,6 @@ func TestInstanceInitAddsDefaultGlobalProtocolWhenEmpty(t
*testing.T) {
assert.Equal(t, constant.TriProtocol, tri.Name)
assert.Equal(t, constant.DefaultTripleProtocolPort, tri.Port)
assert.Equal(t, "4mib", tri.MaxServerRecvMsgSize)
-
- root := legacyconfig.GetRootConfig()
- require.NotNil(t, root)
- require.NotNil(t, root.Protocols[constant.TriProtocol])
- assert.Equal(t, constant.TriProtocol,
root.Protocols[constant.TriProtocol].Name)
- assert.Equal(t, constant.DefaultTripleProtocolPort,
root.Protocols[constant.TriProtocol].Port)
}
func TestInstanceInitTranslatesGlobalRegistryAddress(t *testing.T) {
@@ -289,10 +282,17 @@ func
TestInstanceInitRejectsDuplicateGlobalRegistryAddress(t *testing.T) {
assert.Contains(t, err.Error(), "duplicate registry address")
}
-func TestInstanceInitMirrorsTLSConfigToCompatRootConfig(t *testing.T) {
- restoreCompatRootConfig(t)
+func TestInstanceInitPropagatesTLSConfig(t *testing.T) {
+ assertTLS := func(t *testing.T, cfg *global.TLSConfig) {
+ t.Helper()
+ require.NotNil(t, cfg)
+ assert.Equal(t, "ca.pem", cfg.CACertFile)
+ assert.Equal(t, "cert.pem", cfg.TLSCertFile)
+ assert.Equal(t, "key.pem", cfg.TLSKeyFile)
+ assert.Equal(t, "dubbo.example", cfg.TLSServerName)
+ }
- _, err := NewInstance(func(opts *InstanceOptions) {
+ ins, err := NewInstance(func(opts *InstanceOptions) {
opts.TLSConfig = &global.TLSConfig{
CACertFile: "ca.pem",
TLSCertFile: "cert.pem",
@@ -301,17 +301,20 @@ func TestInstanceInitMirrorsTLSConfigToCompatRootConfig(t
*testing.T) {
}
})
require.NoError(t, err)
+ assertTLS(t, ins.insOpts.TLSConfig)
- root := legacyconfig.GetRootConfig()
- require.NotNil(t, root)
- require.NotNil(t, root.TLSConfig)
- assert.Equal(t, "ca.pem", root.TLSConfig.CACertFile)
- assert.Equal(t, "cert.pem", root.TLSConfig.TLSCertFile)
- assert.Equal(t, "key.pem", root.TLSConfig.TLSKeyFile)
- assert.Equal(t, "dubbo.example", root.TLSConfig.TLSServerName)
+ _, err = ins.NewClient(func(options *client.ClientOptions) {
+ assertTLS(t, options.TLS)
+ })
+ require.NoError(t, err)
+
+ _, err = ins.NewServer(func(options *server.ServerOptions) {
+ assertTLS(t, options.TLS)
+ })
+ require.NoError(t, err)
}
-func TestInstanceInitUsesLegacyMetricsDefaults(t *testing.T) {
+func TestInstanceInitUsesGlobalMetricsDefaults(t *testing.T) {
enabled := true
rc := defaultInstanceOptions()
rc.Metrics = &global.MetricsConfig{Enable: &enabled}
@@ -330,9 +333,7 @@ func TestInstanceInitUsesLegacyMetricsDefaults(t
*testing.T) {
assert.True(t, *rc.Metrics.Prometheus.Exporter.Enabled)
}
-func TestInstanceInitPreservesLegacyTracingConfig(t *testing.T) {
- restoreCompatRootConfig(t)
-
+func TestInstanceInitPreservesGlobalTracingConfig(t *testing.T) {
ins, err := NewInstance(func(opts *InstanceOptions) {
opts.Tracing = map[string]*global.TracingConfig{
"jaeger": {
@@ -345,7 +346,7 @@ func TestInstanceInitPreservesLegacyTracingConfig(t
*testing.T) {
assert.Equal(t, "jaeger", ins.insOpts.Provider.TracingKey)
assert.Equal(t, "jaeger", ins.insOpts.Consumer.TracingKey)
- tracing := legacyconfig.GetTracingConfig("jaeger")
+ tracing := ins.insOpts.Tracing["jaeger"]
require.NotNil(t, tracing)
assert.Equal(t, "jaeger", tracing.Name)
assert.Equal(t, "127.0.0.1:6831", tracing.Address)
@@ -353,9 +354,7 @@ func TestInstanceInitPreservesLegacyTracingConfig(t
*testing.T) {
assert.False(t, *tracing.UseAgent)
}
-func
TestInstanceProcessAppliesLegacyDynamicUpdatesAndRefreshesCompatRootConfig(t
*testing.T) {
- restoreCompatRootConfig(t)
-
+func TestInstanceProcessAppliesDynamicUpdatesToLiveOptions(t *testing.T) {
ins, err := NewInstance(func(opts *InstanceOptions) {
opts.Application = &global.ApplicationConfig{
Name: "stable-app",
@@ -402,32 +401,15 @@ dubbo:
assert.Equal(t, "7s", ins.insOpts.Shutdown.ClosingInvokerExpireTime)
require.NotNil(t, ins.insOpts.TLSConfig)
assert.Equal(t, "dubbo.example", ins.insOpts.TLSConfig.TLSServerName)
-
- root := legacyconfig.GetRootConfig()
- require.NotNil(t, root)
- assert.Equal(t, "stable-app", root.Application.Name)
- require.NotNil(t, root.Registries["zk"])
- assert.Equal(t, "9s", root.Registries["zk"].Timeout)
- assert.Equal(t, "11s", root.Consumer.RequestTimeout)
- require.NotNil(t, root.TLSConfig)
- assert.Equal(t, "dubbo.example", root.TLSConfig.TLSServerName)
}
func TestInstanceProcessDoesNotMutateLiveOptionsOnInvalidPayload(t *testing.T)
{
- restoreCompatRootConfig(t)
-
ins, err := NewInstance(WithName("stable-app"))
require.NoError(t, err)
- rootBefore := legacyconfig.GetRootConfig()
- require.NotNil(t, rootBefore)
- assert.Equal(t, "stable-app", rootBefore.Application.Name)
ins.insOpts.Process(&config_center.ConfigChangeEvent{Value: 123})
assert.Equal(t, "stable-app", ins.insOpts.Application.Name)
- rootAfter := legacyconfig.GetRootConfig()
- require.NotNil(t, rootAfter)
- assert.Equal(t, "stable-app", rootAfter.Application.Name)
}
func TestSetProviderServiceRegistersByReference(t *testing.T) {
@@ -491,15 +473,3 @@ func resetDynamicConfiguration(t *testing.T) {
env.SetDynamicConfiguration(original)
})
}
-
-func restoreCompatRootConfig(t *testing.T) {
- t.Helper()
- original := legacyconfig.GetRootConfig()
- if original == nil {
- return
- }
- originalValue := *original
- t.Cleanup(func() {
- legacyconfig.SetRootConfig(originalValue)
- })
-}
diff --git a/instance_options_init.go b/instance_options_init.go
index 950a21c2a..dac0987c0 100644
--- a/instance_options_init.go
+++ b/instance_options_init.go
@@ -46,6 +46,7 @@ import (
"dubbo.apache.org/dubbo-go/v3/global"
"dubbo.apache.org/dubbo-go/v3/internal"
dubboLogger "dubbo.apache.org/dubbo-go/v3/logger"
+ _ "dubbo.apache.org/dubbo-go/v3/logger/core/zap"
"dubbo.apache.org/dubbo-go/v3/metrics"
metricsConfigCenter "dubbo.apache.org/dubbo-go/v3/metrics/config_center"
"dubbo.apache.org/dubbo-go/v3/otel/trace"
@@ -719,6 +720,4 @@ func (rc *InstanceOptions) Process(event
*config_center.ConfigChangeEvent) {
rc.Consumer.RequestTimeout = update.Consumer.RequestTimeout
gostLogger.Infof("ConsumerConfig's RequestTimeout was
dynamically updated, new value:%v", rc.Consumer.RequestTimeout)
}
-
- setCompatRootConfig(compatRootConfig(rc))
}
diff --git a/options.go b/options.go
index b0efaad9a..349f0055a 100644
--- a/options.go
+++ b/options.go
@@ -105,7 +105,6 @@ func (rc *InstanceOptions) init(opts ...InstanceOption)
error {
if err := rc.finalizeGlobalOptionsWithRuntimeActivation(true); err !=
nil {
return err
}
- setCompatRootConfig(compatRootConfig(rc))
if err := rc.initMetadataReport(); err != nil {
return err
