gocommon/pkg/internal/nacos/config.go

package nacos

import (
	"errors"
	"fmt"
	"strings"

	cons "git.shuncheng.lu/bigthing/gocommon/pkg/internal/constant"
	"git.shuncheng.lu/bigthing/gocommon/pkg/internal/util"
	"github.com/nacos-group/nacos-sdk-go/clients"
	"github.com/nacos-group/nacos-sdk-go/clients/config_client"
	"github.com/nacos-group/nacos-sdk-go/clients/naming_client"
	"github.com/nacos-group/nacos-sdk-go/common/constant"
)

// go get golang.org/x/tools/cmd/stringer
//go:generate stringer -type=NamingType
type NamingType uint8

const (
	NacosDiscover NamingType = iota + 1
	NacosRegister
)

type NamingInfo struct {
	ProjectName string
	GroupName   string
	ClusterName string
	ServerPort  uint64
	ServerHost  string
	naming_client.INamingClient
}

type ConfigInfo struct {
	DataId string
	Group  string
	config_client.IConfigClient
}

func NewHost(str string) ([]constant.ServerConfig, error) {
	split := strings.Split(str, ",")
	result := make([]constant.ServerConfig, 0, len(split))
	for _, elem := range split {
		if strings.TrimSpace(elem) == "" {
			continue
		}
		ipAndPort := strings.Split(elem, ":")
		if len(ipAndPort) != 2 {
			return nil, errors.New("ip and port 解析失败")
		}
		result = append(result, constant.ServerConfig{
			IpAddr: ipAndPort[0],
			Port:   util.String2Uint64(ipAndPort[1]),
		})
	}
	if len(result) == 0 {
		return nil, errors.New("nacos not set host")
	}
	return result, nil
}

func getNacosConfig(key string, setAndAssertNilFunc util.SetAndAssertNil) (map[string]string, error) {
	config := make(map[string]string, 0)
	if err := setAndAssertNilFunc(config, key, "host"); err != nil {
		return nil, err
	}
	if err := setAndAssertNilFunc(config, key, "log_path"); err != nil {
		return nil, err
	}
	if err := setAndAssertNilFunc(config, key, "log_level", "debug"); err != nil {
		return nil, err
	}
	if err := setAndAssertNilFunc(config, key, "namespace_id"); err != nil {
		util.Warnf("Nacos config find warn: %v", err)
	}
	if err := setAndAssertNilFunc(config, key, "user_name"); err != nil {
		//return nil, err
		util.Warnf("Nacos config find warn: %v", err)
	}
	if err := setAndAssertNilFunc(config, key, "password"); err != nil {
		//return nil, err
		util.Warnf("Nacos config find warn: %v", err)
	}
	if err := setAndAssertNilFunc(config, key, "timeout", "5000"); err != nil {
		return nil, err
	}
	//if err := setAndAssertNilFunc(config, key, "listen_interval", "10000"); err != nil {
	//	return nil, err
	//}
	return config, nil
}

func NewNacosNameClient(_type NamingType, setAndAssertNilFunc util.SetAndAssertNil) (*NamingInfo, error) {
	config, err := getNacosConfig("nacos-server", setAndAssertNilFunc)
	if err != nil {
		return nil, err
	}
	hosts, err := NewHost(config["host"])
	if err != nil {
		return nil, err
	}

	switch _type {
	case NacosRegister:
		_ = setAndAssertNilFunc(config, "nacos-server", "server_port")
		if config["server_port"] == "" {
			configTmp := map[string]string{}
			if err := setAndAssertNilFunc(configTmp, cons.ApplicationName, cons.PortName); err != nil {
				return nil, errors.New(fmt.Sprintf("config nacos.server_port or %s.%s == nil", cons.ApplicationName, cons.PortName))
			}
			// 兼容历史逻辑
			config["server_port"] = configTmp[cons.PortName]
		}
		_ = setAndAssertNilFunc(config, "nacos-server", "server_name")
		if config["server_name"] == "" {
			configTmp := map[string]string{}
			if err := setAndAssertNilFunc(configTmp, cons.ApplicationName, cons.ProjectName); err != nil {
				return nil, errors.New(fmt.Sprintf("config nacos.project_name or %s.%s is null", cons.ApplicationName, cons.ProjectName))
			}
			// 兼容历史逻辑
			config["server_name"] = configTmp[cons.ProjectName]
		}
		// 这些默认值的不需要校验
		if err := setAndAssertNilFunc(config, "nacos-server", "server_host", ""); err != nil {
			util.Warnf("Nacos config find warn: %v", err)
			localIP, ipErr := util.GetLocalIP()
			if ipErr != nil {
				return nil, ipErr
			}
			config["server_host"] = localIP
		}
		if err := setAndAssertNilFunc(config, "nacos-server", "group_name", "DEFAULT_GROUP"); err != nil {
			return nil, err
		}
		if err := setAndAssertNilFunc(config, "nacos-server", "cluster_name", "DEFAULT"); err != nil {
			return nil, err
		}
	case NacosDiscover:

	}

	nacosClient, err := clients.CreateNamingClient(map[string]interface{}{
		"serverConfigs": hosts,
		"clientConfig": constant.ClientConfig{
			LogLevel:  config["log_level"], // debug,info,warn,error
			TimeoutMs: util.String2Uint64(config["timeout"]),
			//ListenInterval:      util.String2Uint64(config["listen_interval"]), // 无效字段
			NotLoadCacheAtStart: true,
			LogDir:              config["log_path"],
			Username:            config["user_name"],
			Password:            config["password"],
			NamespaceId:         config["namespace_id"],
		},
	})
	if err != nil {
		return nil, err
	}
	util.Debugf("%s load config success, config=%+v", _type, config)
	return &NamingInfo{
		ProjectName:   config["server_name"],
		ServerPort:    util.String2Uint64(config["server_port"]),
		ServerHost:    config["server_host"],
		GroupName:     config["group_name"],
		ClusterName:   config["cluster_name"],
		INamingClient: nacosClient,
	}, nil
}

func NewNacosConfigClient(setAndAssertNilFunc util.SetAndAssertNil) (*ConfigInfo, error) {
	config, err := getNacosConfig("nacos-config", setAndAssertNilFunc)
	if err != nil {
		return nil, err
	}
	if err := setAndAssertNilFunc(config, "nacos-config", "data_id"); err != nil {
		return nil, err
	}
	if err := setAndAssertNilFunc(config, "nacos-config", "group", "DEFAULT_GROUP"); err != nil {
		return nil, err
	}
	hosts, err := NewHost(config["host"])
	if err != nil {
		return nil, err
	}
	client, err := clients.CreateConfigClient(map[string]interface{}{
		"serverConfigs": hosts,
		"clientConfig": constant.ClientConfig{
			LogLevel:  config["log_level"], // debug,info,warn,error
			TimeoutMs: util.String2Uint64(config["timeout"]),
			//ListenInterval:      util.String2Uint64(config["listen_interval"]), // 无效字段
			NotLoadCacheAtStart: true,
			LogDir:              config["log_dir"],
			Username:            config["user_name"],
			Password:            config["password"],
			NamespaceId:         config["namespace_id"],
		},
	})
	if err != nil {
		return nil, err
	}
	util.Debugf("NacosConfig load config success, config=%+v", config)
	return &ConfigInfo{
		DataId:        config["data_id"],
		Group:         config["group"],
		IConfigClient: client,
	}, nil
}