apiServer-service/utils/nacos/service.go

package nacos

import (
	"errors"
	"os"
	"strconv"
	"sync"

	"github.com/nacos-group/nacos-sdk-go/v2/clients"
	"github.com/nacos-group/nacos-sdk-go/v2/clients/naming_client"
	"github.com/nacos-group/nacos-sdk-go/v2/model"
	"github.com/nacos-group/nacos-sdk-go/v2/vo"
)

var (
	namingClient naming_client.INamingClient
	namingMu     sync.Mutex
	groupName    string
	serviceCache sync.Map
)

func NewNacosRegistry() (naming_client.INamingClient, error) {
	namingMu.Lock()
	defer namingMu.Unlock()

	if namingClient != nil {
		return namingClient, nil
	}

	if err := InitNacosRegistryConfig(); err != nil {
		return nil, err
	}

	groupName = os.Getenv("NACOS_GROUP_NAME")
	var err error
	namingClient, err = clients.NewNamingClient(
		vo.NacosClientParam{
			ClientConfig:  cc,
			ServerConfigs: sc,
		},
	)
	if err != nil {
		return nil, err
	}
	return namingClient, nil
}

func RegisterService() error {
	client, err := NewNacosRegistry()
	if err != nil {
		return err
	}

	serviceName := os.Getenv("NACOS_SERVICE_NAME")
	host := os.Getenv("NACOS_SERVICE_HOST")
	if serviceName == "" || host == "" {
		return errors.New("NACOS_SERVICE_NAME 和 NACOS_SERVICE_HOST 必须配置")
	}

	port, err := strconv.Atoi(os.Getenv("NACOS_SERVICE_PORT"))
	if err != nil {
		port = 8848
	}
	weight, err := strconv.Atoi(os.Getenv("NACOS_SERVICE_WEIGHT"))
	if err != nil {
		weight = 10
	}

	_, err = client.RegisterInstance(vo.RegisterInstanceParam{
		Ip:          host,
		Port:        uint64(port),
		ServiceName: serviceName,
		Weight:      float64(weight),
		Enable:      true,
		Healthy:     true,
		Ephemeral:   false,
		GroupName:   groupName,
	})
	return err
}

func DiscoverServiceList(serviceName string) ([]model.Instance, error) {
	client, err := NewNacosRegistry()
	if err != nil {
		return nil, err
	}
	return client.SelectInstances(vo.SelectInstancesParam{
		ServiceName: serviceName,
		HealthyOnly: false,
		GroupName:   groupName,
	})
}

func DiscoverService(serviceName string) (model.Instance, error) {
	if cached, ok := serviceCache.Load(serviceName); ok {
		cachedInstance := cached.(model.Instance)
		client, err := NewNacosRegistry()
		if err != nil {
			return cachedInstance, err
		}
		instance, err := client.SelectOneHealthyInstance(vo.SelectOneHealthInstanceParam{
			ServiceName: serviceName,
			GroupName:   groupName,
		})
		if err != nil {
			return cachedInstance, err
		}
		serviceCache.Store(serviceName, *instance)
		return *instance, nil
	}

	client, err := NewNacosRegistry()
	if err != nil {
		return model.Instance{}, err
	}
	instance, err := client.SelectOneHealthyInstance(vo.SelectOneHealthInstanceParam{
		ServiceName: serviceName,
		GroupName:   groupName,
	})
	if err != nil {
		return model.Instance{}, err
	}
	serviceCache.Store(serviceName, *instance)
	return *instance, nil
}