config/config_api.go

/*
 * 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

import (
	"context"
	"time"
)

//////////////////////////////////// default registry config
const (
	// defaultZKAddr is the default registry address of zookeeper
	defaultZKAddr = "127.0.0.1:2181"

	// defaultConsulAddr is the default registry address of consul
	defaultConsulAddr = "127.0.0.1:8500"

	// defaultNacosAddr is the default registry address of nacos
	defaultNacosAddr = "127.0.0.1:8848"

	// defaultRegistryTimeout is the default registry timeout
	defaultRegistryTimeout = "3s"
)

// NewDefaultRegistryConfig New default registry config
// the input @protocol can only be:
// "zookeeper" with default addr "127.0.0.1:2181"
// "consul" with default addr "127.0.0.1:8500"
// "nacos" with default addr "127.0.0.1:8848"
func NewDefaultRegistryConfig(protocol string) *RegistryConfig {
	switch protocol {
	case "zookeeper":
		return &RegistryConfig{
			Protocol:   protocol,
			Address:    defaultZKAddr,
			TimeoutStr: defaultRegistryTimeout,
		}
	case "consul":
		return &RegistryConfig{
			Protocol:   protocol,
			Address:    defaultConsulAddr,
			TimeoutStr: defaultRegistryTimeout,
		}
	case "nacos":
		return &RegistryConfig{
			Protocol:   protocol,
			Address:    defaultNacosAddr,
			TimeoutStr: defaultRegistryTimeout,
		}
	default:
		return &RegistryConfig{
			Protocol: protocol,
		}
	}
}

///////////////////////////////////// registry config api
type RegistryConfigOpt func(config *RegistryConfig) *RegistryConfig

// NewRegistryConfig creates New RegistryConfig with @opts
func NewRegistryConfig(opts ...RegistryConfigOpt) *RegistryConfig {
	newRegistryConfig := NewDefaultRegistryConfig("")
	for _, v := range opts {
		newRegistryConfig = v(newRegistryConfig)
	}
	return newRegistryConfig
}

// WithRegistryProtocol returns RegistryConfigOpt with given @regProtocol name
func WithRegistryProtocol(regProtocol string) RegistryConfigOpt {
	return func(config *RegistryConfig) *RegistryConfig {
		config.Protocol = regProtocol
		return config
	}
}

// WithRegistryAddress returns RegistryConfigOpt with given @addr registry address
func WithRegistryAddress(addr string) RegistryConfigOpt {
	return func(config *RegistryConfig) *RegistryConfig {
		config.Address = addr
		return config
	}
}

// WithRegistryTimeOut returns RegistryConfigOpt with given @timeout registry config
func WithRegistryTimeOut(timeout string) RegistryConfigOpt {
	return func(config *RegistryConfig) *RegistryConfig {
		config.TimeoutStr = timeout
		return config
	}
}

// WithRegistryGroup returns RegistryConfigOpt with given @group registry group
func WithRegistryGroup(group string) RegistryConfigOpt {
	return func(config *RegistryConfig) *RegistryConfig {
		config.Group = group
		return config
	}
}

// WithRegistryTTL returns RegistryConfigOpt with given @ttl registry ttl
func WithRegistryTTL(ttl string) RegistryConfigOpt {
	return func(config *RegistryConfig) *RegistryConfig {
		config.TTL = ttl
		return config
	}
}

// WithRegistryUserName returns RegistryConfigOpt with given @userName registry userName
func WithRegistryUserName(userName string) RegistryConfigOpt {
	return func(config *RegistryConfig) *RegistryConfig {
		config.Username = userName
		return config
	}
}

// WithRegistryPassword returns RegistryConfigOpt with given @psw registry password
func WithRegistryPassword(psw string) RegistryConfigOpt {
	return func(config *RegistryConfig) *RegistryConfig {
		config.Password = psw
		return config
	}
}

// WithRegistrySimplified returns RegistryConfigOpt with given @simplified registry simplified flag
func WithRegistrySimplified(simplified bool) RegistryConfigOpt {
	return func(config *RegistryConfig) *RegistryConfig {
		config.Simplified = simplified
		return config
	}
}

// WithRegistryPreferred returns RegistryConfig with given @preferred registry preferred flag
func WithRegistryPreferred(preferred bool) RegistryConfigOpt {
	return func(config *RegistryConfig) *RegistryConfig {
		config.Preferred = preferred
		return config
	}
}

// WithRegistryWeight returns RegistryConfigOpt with given @weight registry weight flag
func WithRegistryWeight(weight int64) RegistryConfigOpt {
	return func(config *RegistryConfig) *RegistryConfig {
		config.Weight = weight
		return config
	}
}

// WithRegistryParams returns RegistryConfigOpt with given registry @params
func WithRegistryParams(params map[string]string) RegistryConfigOpt {
	return func(config *RegistryConfig) *RegistryConfig {
		config.Params = params
		return config
	}
}

///////////////////////////////////// consumer config api
// ConsumerConfigOpt is the options to init ConsumerConfig
type ConsumerConfigOpt func(config *ConsumerConfig) *ConsumerConfig

// NewDefaultConsumerConfig returns default ConsumerConfig
// with connection timeout = 3s, request timeout = 3s
func NewDefaultConsumerConfig() *ConsumerConfig {
	check := true
	newConsumerConfig := &ConsumerConfig{
		BaseConfig:     BaseConfig{},
		Registries:     make(map[string]*RegistryConfig, 8),
		References:     make(map[string]*ReferenceConfig, 8),
		ConnectTimeout: 3 * time.Second,
		RequestTimeout: 3 * time.Second,
		Check:          &check,
	}
	return newConsumerConfig
}

// NewConsumerConfig returns ConsumerConfig with @opts
func NewConsumerConfig(opts ...ConsumerConfigOpt) *ConsumerConfig {
	newConfig := NewDefaultConsumerConfig()
	for _, v := range opts {
		v(newConfig)
	}
	return newConfig
}

// WithConsumerAppConfig returns ConsumerConfigOpt with given @appConfig
func WithConsumerAppConfig(appConfig *ApplicationConfig) ConsumerConfigOpt {
	return func(config *ConsumerConfig) *ConsumerConfig {
		config.ApplicationConfig = appConfig
		return config
	}
}

// WithConsumerRegistryConfig returns ConsumerConfigOpt with given @registryKey and @regConfig
func WithConsumerRegistryConfig(registryKey string, regConfig *RegistryConfig) ConsumerConfigOpt {
	return func(config *ConsumerConfig) *ConsumerConfig {
		config.Registries[registryKey] = regConfig
		return config
	}
}

// WithConsumerReferenceConfig returns ConsumerConfigOpt with
func WithConsumerReferenceConfig(referenceKey string, refConfig *ReferenceConfig) ConsumerConfigOpt {
	return func(config *ConsumerConfig) *ConsumerConfig {
		config.References[referenceKey] = refConfig
		return config
	}
}

// WithConsumerConnTimeout returns ConsumerConfigOpt with given consumer conn @timeout
func WithConsumerConnTimeout(timeout time.Duration) ConsumerConfigOpt {
	return func(config *ConsumerConfig) *ConsumerConfig {
		config.ConnectTimeout = timeout
		return config
	}
}

// WithConsumerRequestTimeout returns ConsumerConfigOpt with given consumer request @timeout
func WithConsumerRequestTimeout(timeout time.Duration) ConsumerConfigOpt {
	return func(config *ConsumerConfig) *ConsumerConfig {
		config.RequestTimeout = timeout
		return config
	}
}

// WithConsumerConfigCenterConfig returns ConsumerConfigOpt with given @configCenterConfig
func WithConsumerConfigCenterConfig(configCenterConfig *ConfigCenterConfig) ConsumerConfigOpt {
	return func(config *ConsumerConfig) *ConsumerConfig {
		config.ConfigCenterConfig = configCenterConfig
		return config
	}
}

// WithConsumerConfigCheck returns ConsumerConfigOpt with given @check flag
func WithConsumerConfigCheck(check bool) ConsumerConfigOpt {
	return func(config *ConsumerConfig) *ConsumerConfig {
		*config.Check = check
		return config
	}
}

//////////////////////////////////// reference config api
// ReferenceConfigOpt is consumer's reference config
type ReferenceConfigOpt func(config *ReferenceConfig) *ReferenceConfig

// NewDefaultReferenceConfig returns empty ReferenceConfig
func NewDefaultReferenceConfig() *ReferenceConfig {
	newReferenceConfig := NewReferenceConfig("", context.Background())
	newReferenceConfig.Methods = make([]*MethodConfig, 0, 8)
	newReferenceConfig.Params = make(map[string]string, 8)
	return newReferenceConfig
}

// NewReferenceConfigByAPI returns ReferenceConfig with given @opts
func NewReferenceConfigByAPI(opts ...ReferenceConfigOpt) *ReferenceConfig {
	newreferenceConfig := NewDefaultReferenceConfig()
	for _, v := range opts {
		v(newreferenceConfig)
	}
	return newreferenceConfig
}

// WithReferenceRegistry returns ReferenceConfigOpt with given registryKey: @registry
func WithReferenceRegistry(registry string) ReferenceConfigOpt {
	return func(config *ReferenceConfig) *ReferenceConfig {
		config.Registry = registry
		return config
	}
}

// WithReferenceProtocol returns ReferenceConfigOpt with given protocolKey: @protocol
func WithReferenceProtocol(protocol string) ReferenceConfigOpt {
	return func(config *ReferenceConfig) *ReferenceConfig {
		config.Protocol = protocol
		return config
	}
}

// WithReferenceInterface returns ReferenceConfigOpt with given @interfaceName
func WithReferenceInterface(interfaceName string) ReferenceConfigOpt {
	return func(config *ReferenceConfig) *ReferenceConfig {
		config.InterfaceName = interfaceName
		return config
	}
}

// WithReferenceCluster returns ReferenceConfigOpt with given cluster name: @cluster
func WithReferenceCluster(cluster string) ReferenceConfigOpt {
	return func(config *ReferenceConfig) *ReferenceConfig {
		config.Cluster = cluster
		return config
	}
}

// WithReferenceMethod returns ReferenceConfigOpt with given @method, @retries, and load balance: @lb
func WithReferenceMethod(methodName, retries, lb string) ReferenceConfigOpt {
	return func(config *ReferenceConfig) *ReferenceConfig {
		config.Methods = append(config.Methods, &MethodConfig{
			Name:        methodName,
			Retries:     retries,
			LoadBalance: lb,
		})
		return config
	}
}

///////////////////////////////////// provider config api
// ProviderConfigOpt is the
type ProviderConfigOpt func(config *ProviderConfig) *ProviderConfig

// NewDefaultProviderConfig returns ProviderConfig with default ApplicationConfig
func NewDefaultProviderConfig() *ProviderConfig {
	newConsumerConfig := &ProviderConfig{
		BaseConfig: BaseConfig{
			ApplicationConfig: &ApplicationConfig{
				Name:         "dubbo",
				Module:       "module",
				Organization: "dubbo_org",
				Owner:        "dubbo",
			},
		},
		Services:   make(map[string]*ServiceConfig),
		Registries: make(map[string]*RegistryConfig, 8),
		Protocols:  make(map[string]*ProtocolConfig, 8),
	}
	return newConsumerConfig
}

// NewProviderConfig returns ProviderConfig with given @opts
func NewProviderConfig(opts ...ProviderConfigOpt) *ProviderConfig {
	newConfig := NewDefaultProviderConfig()
	for _, v := range opts {
		v(newConfig)
	}
	return newConfig
}

// WithPrividerRegistryConfig returns ProviderConfigOpt with given registry config: @regConfig
func WithPrividerRegistryConfig(regConfig *RegistryConfig) ProviderConfigOpt {
	return func(config *ProviderConfig) *ProviderConfig {
		config.Registries[regConfig.Protocol] = regConfig
		return config
	}
}

// WithProviderAppConfig returns ProviderConfigOpt with given @appConfig
func WithProviderAppConfig(appConfig *ApplicationConfig) ProviderConfigOpt {
	return func(config *ProviderConfig) *ProviderConfig {
		config.ApplicationConfig = appConfig
		return config
	}
}

// WithProviderServices returns ProviderConfig with given serviceNameKey @serviceName and @serviceConfig
func WithProviderServices(serviceName string, serviceConfig *ServiceConfig) ProviderConfigOpt {
	return func(config *ProviderConfig) *ProviderConfig {
		config.Services[serviceName] = serviceConfig
		return config
	}
}

// WithProviderProtocol returns ProviderConfigOpt with given @protocolKey, protocolName @protocol and @port
func WithProviderProtocol(protocolKey, protocol, port string) ProviderConfigOpt {
	return func(config *ProviderConfig) *ProviderConfig {
		config.Protocols[protocolKey] = &ProtocolConfig{
			Name: protocol,
			Port: port,
		}
		return config
	}
}

// WithProviderRegistry returns ProviderConfigOpt with given @registryKey and registry @registryConfig
func WithProviderRegistry(registryKey string, registryConfig *RegistryConfig) ProviderConfigOpt {
	return func(config *ProviderConfig) *ProviderConfig {
		config.Registries[registryKey] = registryConfig
		return config
	}
}

/////////////////////////////////////// service config api
// ServiceConfigOpt is the option to init ServiceConfig
type ServiceConfigOpt func(config *ServiceConfig) *ServiceConfig

// NewDefaultServiceConfig returns default ServiceConfig
func NewDefaultServiceConfig() *ServiceConfig {
	newServiceConfig := NewServiceConfig("", context.Background())
	newServiceConfig.Params = make(map[string]string)
	newServiceConfig.Methods = make([]*MethodConfig, 0, 8)
	return newServiceConfig
}

// NewServiceConfigByAPI is named as api, because there is NewServiceConfig func already declared
// NewServiceConfigByAPI returns ServiceConfig with given @opts
func NewServiceConfigByAPI(opts ...ServiceConfigOpt) *ServiceConfig {
	defaultServiceConfig := NewDefaultServiceConfig()
	for _, v := range opts {
		v(defaultServiceConfig)
	}
	return defaultServiceConfig
}

// WithServiceRegistry returns ServiceConfigOpt with given registryKey @registry
func WithServiceRegistry(registry string) ServiceConfigOpt {
	return func(config *ServiceConfig) *ServiceConfig {
		config.Registry = registry
		return config
	}
}

// WithServiceProtocol returns ServiceConfigOpt with given protocolKey @protocol
func WithServiceProtocol(protocol string) ServiceConfigOpt {
	return func(config *ServiceConfig) *ServiceConfig {
		config.Protocol = protocol
		return config
	}
}

// WithServiceInterface returns ServiceConfigOpt with given @interfaceName
func WithServiceInterface(interfaceName string) ServiceConfigOpt {
	return func(config *ServiceConfig) *ServiceConfig {
		config.InterfaceName = interfaceName
		return config
	}
}

// WithServiceLoadBalance returns ServiceConfigOpt with given load balance @lb
func WithServiceLoadBalance(lb string) ServiceConfigOpt {
	return func(config *ServiceConfig) *ServiceConfig {
		config.Loadbalance = lb
		return config
	}
}

// WithServiceWarmUpTime returns ServiceConfigOpt with given @warmUp time
func WithServiceWarmUpTime(warmUp string) ServiceConfigOpt {
	return func(config *ServiceConfig) *ServiceConfig {
		config.Warmup = warmUp
		return config
	}
}

// WithServiceCluster returns ServiceConfigOpt with given cluster name @cluster
func WithServiceCluster(cluster string) ServiceConfigOpt {
	return func(config *ServiceConfig) *ServiceConfig {
		config.Cluster = cluster
		return config
	}
}

// WithServiceMethod returns ServiceConfigOpt with given @name, @retries and load balance @lb
func WithServiceMethod(name, retries, lb string) ServiceConfigOpt {
	return func(config *ServiceConfig) *ServiceConfig {
		config.Methods = append(config.Methods, &MethodConfig{
			Name:        name,
			Retries:     retries,
			LoadBalance: lb,
		})
		return config
	}
}

///////////////////////////////////////// Application config api
// ApplicationConfigOpt is option to init ApplicationConfig
type ApplicationConfigOpt func(config *ApplicationConfig) *ApplicationConfig

// NewDefaultApplicationConfig returns ApplicationConfig with default
// name: dubbo.io
// module: sample
// organization: dubbo.io
// owner: dubbogo
// version: 0.0.1
// environment dev
func NewDefaultApplicationConfig() *ApplicationConfig {
	newAppConfig := &ApplicationConfig{
		Name:         "dubbo.io",
		Module:       "sample",
		Organization: "dubbo.io",
		Owner:        "dubbogo",
		Version:      "0.0.1",
		Environment:  "dev",
	}
	return newAppConfig
}

// NewApplicationConfig is named as api, because there is NewServiceConfig func already declared
// NewApplicationConfig returns ApplicationConfig wigh default application config
func NewApplicationConfig(opts ...ApplicationConfigOpt) *ApplicationConfig {
	defaultServiceConfig := NewDefaultApplicationConfig()
	for _, v := range opts {
		v(defaultServiceConfig)
	}
	return defaultServiceConfig
}

// WithAppName returns ApplicationConfigOpt with given @name
func WithAppName(name string) ApplicationConfigOpt {
	return func(config *ApplicationConfig) *ApplicationConfig {
		config.Name = name
		return config
	}
}

// WithAppModule returns ApplicationConfigOpt with given @module
func WithAppModule(module string) ApplicationConfigOpt {
	return func(config *ApplicationConfig) *ApplicationConfig {
		config.Module = module
		return config
	}
}

// WithAppOrganization returns ApplicationConfigOpt wight given organization @org
func WithAppOrganization(org string) ApplicationConfigOpt {
	return func(config *ApplicationConfig) *ApplicationConfig {
		config.Organization = org
		return config
	}
}

// WithAppOwner returns ApplicationConfigOpt with given @owner
func WithAppOwner(owner string) ApplicationConfigOpt {
	return func(config *ApplicationConfig) *ApplicationConfig {
		config.Owner = owner
		return config
	}
}

// WithAppVersion returns ApplicationConfigOpt with given version @version
func WithAppVersion(version string) ApplicationConfigOpt {
	return func(config *ApplicationConfig) *ApplicationConfig {
		config.Version = version
		return config
	}
}

// WithAppEnvironment returns ApplicationConfigOpt wigh given environment @env
func WithAppEnvironment(env string) ApplicationConfigOpt {
	return func(config *ApplicationConfig) *ApplicationConfig {
		config.Environment = env
		return config
	}
}