github.com/polarismesh/polaris@v1.17.8/config/watcher.go

/**
 * Tencent is pleased to support the open source community by making Polaris available.
 *
 * Copyright (C) 2019 THL A29 Limited, a Tencent company. All rights reserved.
 *
 * Licensed under the BSD 3-Clause License (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * https://opensource.org/licenses/BSD-3-Clause
 *
 * 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"
	"sync"

	apiconfig "github.com/polarismesh/specification/source/go/api/v1/config_manage"
	"go.uber.org/zap"

	"github.com/polarismesh/polaris/common/eventhub"
	"github.com/polarismesh/polaris/common/model"
	"github.com/polarismesh/polaris/common/utils"
)

const (
	QueueSize = 10240
)

type FileReleaseCallback func(clientId string, rsp *apiconfig.ConfigClientResponse) bool

type watchContext struct {
	watchConfigFiles []*apiconfig.ClientConfigFileInfo
	clientId         string
	fileReleaseCb    FileReleaseCallback
	ClientVersion    uint64
}

// watchCenter 处理客户端订阅配置请求，监听配置文件发布事件通知客户端
type watchCenter struct {
	connManager *connManager
	subCtx      *eventhub.SubscribtionContext
	lock        sync.Mutex
	// fileId -> clientId -> watchContext
	configFileWatchers *utils.SyncMap[string, *utils.SyncMap[string, *watchContext]]
}

// NewWatchCenter 创建一个客户端监听配置发布的处理中心
func NewWatchCenter() (*watchCenter, error) {
	wc := &watchCenter{
		configFileWatchers: utils.NewSyncMap[string, *utils.SyncMap[string, *watchContext]](),
	}

	var err error
	wc.subCtx, err = eventhub.Subscribe(eventhub.ConfigFilePublishTopic, wc, eventhub.WithQueueSize(QueueSize))
	if err != nil {
		return nil, err
	}
	return wc, nil
}

// PreProcess do preprocess logic for event
func (wc *watchCenter) PreProcess(_ context.Context, e any) any {
	return e
}

// OnEvent event process logic
func (wc *watchCenter) OnEvent(ctx context.Context, arg any) error {
	event, ok := arg.(*eventhub.PublishConfigFileEvent)
	if !ok {
		log.Warn("[Config][Watcher] receive invalid event type")
		return nil
	}
	wc.notifyToWatchers(event.Message)
	return nil
}

// AddWatcher 新增订阅者
func (wc *watchCenter) AddWatcher(clientId string, watchConfigFiles []*apiconfig.ClientConfigFileInfo,
	fileReleaseCb FileReleaseCallback) {
	if len(watchConfigFiles) == 0 {
		return
	}
	for _, file := range watchConfigFiles {
		watchFileId := utils.GenFileId(file.Namespace.GetValue(), file.Group.GetValue(), file.FileName.GetValue())
		log.Info("[Config][Watcher] add watcher.", zap.Any("client-id", clientId),
			zap.String("watch-file-id", watchFileId), zap.Uint64("client-version", file.Version.GetValue()))

		watchers, _ := wc.configFileWatchers.ComputeIfAbsent(watchFileId,
			func(k string) *utils.SyncMap[string, *watchContext] {
				newWatchers := utils.NewSyncMap[string, *watchContext]()
				return newWatchers
			})
		watchers.Store(clientId, &watchContext{
			clientId:         clientId,
			fileReleaseCb:    fileReleaseCb,
			ClientVersion:    file.Version.GetValue(),
			watchConfigFiles: watchConfigFiles,
		})
	}
}

// RemoveWatcher 删除订阅者
func (wc *watchCenter) RemoveWatcher(clientId string, watchConfigFiles []*apiconfig.ClientConfigFileInfo) {
	if len(watchConfigFiles) == 0 {
		return
	}

	for _, file := range watchConfigFiles {
		watchFileId := utils.GenFileId(file.Namespace.GetValue(), file.Group.GetValue(), file.FileName.GetValue())
		watchers, ok := wc.configFileWatchers.Load(watchFileId)
		if !ok {
			continue
		}
		watchers.Delete(clientId)
	}
}

func (wc *watchCenter) notifyToWatchers(publishConfigFile *model.SimpleConfigFileRelease) {
	watchFileId := utils.GenFileId(publishConfigFile.Namespace, publishConfigFile.Group, publishConfigFile.FileName)

	log.Info("[Config][Watcher] received config file publish message.", zap.String("file", watchFileId))
	watchers, ok := wc.configFileWatchers.Load(watchFileId)
	if !ok {
		return
	}

	response := GenConfigFileResponse(publishConfigFile.Namespace, publishConfigFile.Group,
		publishConfigFile.FileName, "", publishConfigFile.Md5, publishConfigFile.Version)

	waitNotifiers := watchers.Values()
	for _, watchCtx := range waitNotifiers {
		clientId := watchCtx.clientId
		if watchCtx.ClientVersion < publishConfigFile.Version {
			watchCtx.fileReleaseCb(clientId, response)
			log.Info("[Config][Watcher] notify to client.",
				zap.String("file", watchFileId), zap.String("clientId", clientId),
				zap.Uint64("version", publishConfigFile.Version))
		} else {
			log.Info("[Config][Watcher] notify to client ignore.",
				zap.String("file", watchFileId), zap.String("clientId", clientId),
				zap.Uint64("client-version", watchCtx.ClientVersion),
				zap.Uint64("version", publishConfigFile.Version))
		}
	}
}