434 lines
15 KiB
Go
434 lines
15 KiB
Go
// Copyright © 2023 OpenIM. All rights reserved.
|
||
//
|
||
// Licensed 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 webhook
|
||
|
||
import (
|
||
"context"
|
||
"encoding/json"
|
||
"sync"
|
||
"time"
|
||
|
||
"git.imall.cloud/openim/open-im-server-deploy/pkg/common/config"
|
||
"git.imall.cloud/openim/open-im-server-deploy/pkg/common/storage/model"
|
||
"git.imall.cloud/openim/open-im-server-deploy/pkg/common/storage/database"
|
||
"github.com/openimsdk/tools/errs"
|
||
"github.com/openimsdk/tools/log"
|
||
"github.com/openimsdk/tools/utils/datautil"
|
||
)
|
||
|
||
const (
|
||
// WebhookConfigKey 数据库中的webhook配置键
|
||
WebhookConfigKey = "webhook_config"
|
||
// DefaultRefreshInterval 默认刷新间隔（30秒，方便调试）
|
||
DefaultRefreshInterval = 30 * time.Second
|
||
)
|
||
|
||
// ConfigManager webhook配置管理器，支持从数据库读取和定时刷新
|
||
type ConfigManager struct {
|
||
db database.SystemConfig
|
||
defaultConfig *config.Webhooks
|
||
mu sync.RWMutex
|
||
cachedConfig *config.Webhooks
|
||
lastUpdate time.Time
|
||
refreshInterval time.Duration
|
||
stopCh chan struct{}
|
||
}
|
||
|
||
// NewConfigManager 创建webhook配置管理器
|
||
func NewConfigManager(db database.SystemConfig, defaultConfig *config.Webhooks) *ConfigManager {
|
||
cm := &ConfigManager{
|
||
db: db,
|
||
defaultConfig: defaultConfig,
|
||
cachedConfig: defaultConfig,
|
||
refreshInterval: DefaultRefreshInterval,
|
||
stopCh: make(chan struct{}),
|
||
}
|
||
return cm
|
||
}
|
||
|
||
// Start 启动配置管理器，开始定时刷新
|
||
func (cm *ConfigManager) Start(ctx context.Context) error {
|
||
// 立即加载一次配置
|
||
log.ZInfo(ctx, "webhook config manager starting, initial refresh...")
|
||
if err := cm.Refresh(ctx); err != nil {
|
||
log.ZWarn(ctx, "initial webhook config refresh failed, using default config", err)
|
||
} else {
|
||
currentConfig := cm.GetConfig()
|
||
log.ZInfo(ctx, "webhook config manager started successfully", "url", currentConfig.URL, "refresh_interval", cm.refreshInterval)
|
||
}
|
||
|
||
// 启动定时刷新goroutine
|
||
go cm.refreshLoop(ctx)
|
||
return nil
|
||
}
|
||
|
||
// Stop 停止配置管理器
|
||
func (cm *ConfigManager) Stop() {
|
||
close(cm.stopCh)
|
||
}
|
||
|
||
// refreshLoop 定时刷新循环
|
||
func (cm *ConfigManager) refreshLoop(ctx context.Context) {
|
||
ticker := time.NewTicker(cm.refreshInterval)
|
||
defer ticker.Stop()
|
||
|
||
log.ZInfo(ctx, "webhook config refresh loop started", "interval", cm.refreshInterval)
|
||
|
||
for {
|
||
select {
|
||
case <-ticker.C:
|
||
log.ZDebug(ctx, "webhook config scheduled refresh triggered")
|
||
if err := cm.Refresh(ctx); err != nil {
|
||
log.ZWarn(ctx, "webhook config refresh failed", err)
|
||
}
|
||
case <-cm.stopCh:
|
||
log.ZInfo(ctx, "webhook config refresh loop stopped")
|
||
return
|
||
}
|
||
}
|
||
}
|
||
|
||
// Refresh 从数据库刷新配置
|
||
func (cm *ConfigManager) Refresh(ctx context.Context) error {
|
||
// 从数据库读取配置
|
||
sysConfig, err := cm.db.FindByKey(ctx, WebhookConfigKey)
|
||
if err != nil {
|
||
// 如果查询出错，使用默认配置
|
||
log.ZWarn(ctx, "failed to get webhook config from database, using default config", err)
|
||
cm.mu.Lock()
|
||
cm.cachedConfig = cm.defaultConfig
|
||
cm.lastUpdate = time.Now()
|
||
cm.mu.Unlock()
|
||
return nil
|
||
}
|
||
|
||
// 如果数据库中没有配置，使用默认配置
|
||
if sysConfig == nil {
|
||
cm.mu.Lock()
|
||
cm.cachedConfig = cm.defaultConfig
|
||
cm.lastUpdate = time.Now()
|
||
cm.mu.Unlock()
|
||
log.ZInfo(ctx, "webhook config not found in database, using default config", "default_url", cm.defaultConfig.URL)
|
||
return nil
|
||
}
|
||
|
||
// 检查值类型
|
||
if sysConfig.ValueType != model.SystemConfigValueTypeJSON {
|
||
cm.mu.Lock()
|
||
cm.cachedConfig = cm.defaultConfig
|
||
cm.lastUpdate = time.Now()
|
||
cm.mu.Unlock()
|
||
log.ZWarn(ctx, "webhook config valueType is not json, using default config", nil, "value_type", sysConfig.ValueType)
|
||
return nil
|
||
}
|
||
|
||
// 如果配置被禁用，使用默认配置
|
||
if !sysConfig.Enabled {
|
||
cm.mu.Lock()
|
||
cm.cachedConfig = cm.defaultConfig
|
||
cm.lastUpdate = time.Now()
|
||
cm.mu.Unlock()
|
||
log.ZInfo(ctx, "webhook config is disabled, using default config", "default_url", cm.defaultConfig.URL)
|
||
return nil
|
||
}
|
||
|
||
// 如果配置值为空，使用默认配置
|
||
if sysConfig.Value == "" {
|
||
cm.mu.Lock()
|
||
cm.cachedConfig = cm.defaultConfig
|
||
cm.lastUpdate = time.Now()
|
||
cm.mu.Unlock()
|
||
log.ZInfo(ctx, "webhook config value is empty, using default config", "default_url", cm.defaultConfig.URL)
|
||
return nil
|
||
}
|
||
|
||
valuePreview := sysConfig.Value
|
||
if len(valuePreview) > 100 {
|
||
valuePreview = valuePreview[:100] + "..."
|
||
}
|
||
log.ZDebug(ctx, "webhook config value found", "value_length", len(sysConfig.Value), "value_preview", valuePreview)
|
||
|
||
// 解析配置
|
||
var webhookConfig config.Webhooks
|
||
if err := json.Unmarshal([]byte(sysConfig.Value), &webhookConfig); err != nil {
|
||
// 如果解析失败，使用默认配置
|
||
log.ZWarn(ctx, "failed to unmarshal webhook config, using default config", err)
|
||
cm.mu.Lock()
|
||
cm.cachedConfig = cm.defaultConfig
|
||
cm.lastUpdate = time.Now()
|
||
cm.mu.Unlock()
|
||
return nil
|
||
}
|
||
|
||
// 验证解析后的配置，确保AttentionIds不为nil
|
||
if webhookConfig.AfterSendGroupMsg.AttentionIds == nil {
|
||
webhookConfig.AfterSendGroupMsg.AttentionIds = []string{}
|
||
}
|
||
|
||
normalized, ok := normalizeWebhookConfig(cm.defaultConfig, &webhookConfig)
|
||
if !ok {
|
||
log.ZWarn(ctx, "webhook config URL is empty, using default config", nil)
|
||
cm.mu.Lock()
|
||
cm.cachedConfig = cm.defaultConfig
|
||
cm.lastUpdate = time.Now()
|
||
cm.mu.Unlock()
|
||
return nil
|
||
}
|
||
|
||
// 更新缓存
|
||
cm.mu.Lock()
|
||
oldURL := cm.cachedConfig.URL
|
||
oldAttentionIdsCount := len(cm.cachedConfig.AfterSendGroupMsg.AttentionIds)
|
||
cm.cachedConfig = normalized
|
||
cm.lastUpdate = time.Now()
|
||
newAttentionIdsCount := len(normalized.AfterSendGroupMsg.AttentionIds)
|
||
cm.mu.Unlock()
|
||
|
||
// 如果URL或AttentionIds发生变化，记录日志
|
||
urlChanged := oldURL != webhookConfig.URL
|
||
attentionIdsChanged := oldAttentionIdsCount != newAttentionIdsCount
|
||
if urlChanged || attentionIdsChanged {
|
||
log.ZInfo(ctx, "webhook config updated from database",
|
||
"old_url", oldURL, "new_url", webhookConfig.URL,
|
||
"old_attention_ids_count", oldAttentionIdsCount,
|
||
"new_attention_ids_count", newAttentionIdsCount,
|
||
"url_changed", urlChanged,
|
||
"attention_ids_changed", attentionIdsChanged)
|
||
} else {
|
||
log.ZDebug(ctx, "webhook config refreshed (no change)", "url", webhookConfig.URL, "attention_ids_count", newAttentionIdsCount)
|
||
}
|
||
|
||
return nil
|
||
}
|
||
|
||
// GetConfig 获取当前缓存的配置
|
||
func (cm *ConfigManager) GetConfig() *config.Webhooks {
|
||
cm.mu.RLock()
|
||
defer cm.mu.RUnlock()
|
||
return cm.cachedConfig
|
||
}
|
||
|
||
// normalizeWebhookConfig 校验并填充缺省值，返回是否有效
|
||
func normalizeWebhookConfig(defaultCfg *config.Webhooks, cfg *config.Webhooks) (*config.Webhooks, bool) {
|
||
if cfg == nil {
|
||
return nil, false
|
||
}
|
||
if cfg.URL == "" {
|
||
return nil, false
|
||
}
|
||
|
||
normalized := *cfg // 浅拷贝
|
||
|
||
// 填充默认值，避免数据库配置错误导致回调不可用
|
||
if normalized.AfterSendGroupMsg.AttentionIds == nil {
|
||
normalized.AfterSendGroupMsg.AttentionIds = []string{}
|
||
}
|
||
|
||
applyBeforeDefaults := func(dst *config.BeforeConfig, fallback config.BeforeConfig) {
|
||
if dst.Timeout <= 0 {
|
||
dst.Timeout = fallback.Timeout
|
||
}
|
||
}
|
||
applyAfterDefaults := func(dst *config.AfterConfig, fallback config.AfterConfig) {
|
||
if dst.Timeout <= 0 {
|
||
dst.Timeout = fallback.Timeout
|
||
}
|
||
if dst.AttentionIds == nil {
|
||
dst.AttentionIds = []string{}
|
||
}
|
||
}
|
||
|
||
if defaultCfg != nil {
|
||
applyBeforeDefaults(&normalized.BeforeSendSingleMsg, defaultCfg.BeforeSendSingleMsg)
|
||
applyBeforeDefaults(&normalized.BeforeUpdateUserInfoEx, defaultCfg.BeforeUpdateUserInfoEx)
|
||
applyAfterDefaults(&normalized.AfterUpdateUserInfoEx, defaultCfg.AfterUpdateUserInfoEx)
|
||
applyAfterDefaults(&normalized.AfterSendSingleMsg, defaultCfg.AfterSendSingleMsg)
|
||
applyBeforeDefaults(&normalized.BeforeSendGroupMsg, defaultCfg.BeforeSendGroupMsg)
|
||
applyBeforeDefaults(&normalized.BeforeMsgModify, defaultCfg.BeforeMsgModify)
|
||
applyAfterDefaults(&normalized.AfterSendGroupMsg, defaultCfg.AfterSendGroupMsg)
|
||
applyAfterDefaults(&normalized.AfterMsgSaveDB, defaultCfg.AfterMsgSaveDB)
|
||
applyAfterDefaults(&normalized.AfterUserOnline, defaultCfg.AfterUserOnline)
|
||
applyAfterDefaults(&normalized.AfterUserOffline, defaultCfg.AfterUserOffline)
|
||
applyAfterDefaults(&normalized.AfterUserKickOff, defaultCfg.AfterUserKickOff)
|
||
applyBeforeDefaults(&normalized.BeforeOfflinePush, defaultCfg.BeforeOfflinePush)
|
||
applyBeforeDefaults(&normalized.BeforeOnlinePush, defaultCfg.BeforeOnlinePush)
|
||
applyBeforeDefaults(&normalized.BeforeGroupOnlinePush, defaultCfg.BeforeGroupOnlinePush)
|
||
applyBeforeDefaults(&normalized.BeforeAddFriend, defaultCfg.BeforeAddFriend)
|
||
applyBeforeDefaults(&normalized.BeforeUpdateUserInfo, defaultCfg.BeforeUpdateUserInfo)
|
||
applyAfterDefaults(&normalized.AfterUpdateUserInfo, defaultCfg.AfterUpdateUserInfo)
|
||
applyBeforeDefaults(&normalized.BeforeCreateGroup, defaultCfg.BeforeCreateGroup)
|
||
applyAfterDefaults(&normalized.AfterCreateGroup, defaultCfg.AfterCreateGroup)
|
||
applyBeforeDefaults(&normalized.BeforeMemberJoinGroup, defaultCfg.BeforeMemberJoinGroup)
|
||
applyBeforeDefaults(&normalized.BeforeSetGroupMemberInfo, defaultCfg.BeforeSetGroupMemberInfo)
|
||
applyAfterDefaults(&normalized.AfterSetGroupMemberInfo, defaultCfg.AfterSetGroupMemberInfo)
|
||
applyAfterDefaults(&normalized.AfterQuitGroup, defaultCfg.AfterQuitGroup)
|
||
applyAfterDefaults(&normalized.AfterKickGroupMember, defaultCfg.AfterKickGroupMember)
|
||
applyAfterDefaults(&normalized.AfterDismissGroup, defaultCfg.AfterDismissGroup)
|
||
}
|
||
|
||
return &normalized, true
|
||
}
|
||
|
||
// GetURL 获取当前webhook URL
|
||
func (cm *ConfigManager) GetURL() string {
|
||
cm.mu.RLock()
|
||
defer cm.mu.RUnlock()
|
||
return cm.cachedConfig.URL
|
||
}
|
||
|
||
// SetRefreshInterval 设置刷新间隔
|
||
func (cm *ConfigManager) SetRefreshInterval(interval time.Duration) {
|
||
cm.mu.Lock()
|
||
defer cm.mu.Unlock()
|
||
cm.refreshInterval = interval
|
||
}
|
||
|
||
// GetLastUpdate 获取最后更新时间
|
||
func (cm *ConfigManager) GetLastUpdate() time.Time {
|
||
cm.mu.RLock()
|
||
defer cm.mu.RUnlock()
|
||
return cm.lastUpdate
|
||
}
|
||
|
||
// UpdateAttentionIds 更新webhook配置中的attentionIds（添加或移除群ID）
|
||
// add: true表示添加groupID，false表示移除groupID
|
||
func UpdateAttentionIds(ctx context.Context, db database.SystemConfig, groupID string, add bool) error {
|
||
if groupID == "" {
|
||
return nil
|
||
}
|
||
|
||
if db == nil {
|
||
return nil
|
||
}
|
||
|
||
// 获取当前配置
|
||
sysConfig, err := db.FindByKey(ctx, WebhookConfigKey)
|
||
if err != nil {
|
||
log.ZWarn(ctx, "UpdateAttentionIds: failed to get webhook config from database", err, "groupID", groupID, "add", add)
|
||
return errs.WrapMsg(err, "failed to get webhook config from database")
|
||
}
|
||
|
||
if sysConfig == nil {
|
||
log.ZDebug(ctx, "UpdateAttentionIds: webhook config not found in database, skipping", "groupID", groupID, "add", add)
|
||
return nil
|
||
}
|
||
|
||
if !sysConfig.Enabled {
|
||
log.ZDebug(ctx, "UpdateAttentionIds: webhook config is disabled, skipping", "groupID", groupID, "add", add)
|
||
return nil
|
||
}
|
||
|
||
if sysConfig.Value == "" {
|
||
log.ZDebug(ctx, "UpdateAttentionIds: webhook config value is empty, skipping", "groupID", groupID, "add", add)
|
||
return nil
|
||
}
|
||
|
||
// 检查值类型
|
||
if sysConfig.ValueType != model.SystemConfigValueTypeJSON {
|
||
log.ZWarn(ctx, "UpdateAttentionIds: webhook config valueType is not json, skipping", nil, "groupID", groupID, "add", add, "value_type", sysConfig.ValueType)
|
||
return nil
|
||
}
|
||
|
||
// 解析当前配置
|
||
var webhookConfig config.Webhooks
|
||
if err := json.Unmarshal([]byte(sysConfig.Value), &webhookConfig); err != nil {
|
||
log.ZWarn(ctx, "UpdateAttentionIds: failed to unmarshal webhook config", err, "groupID", groupID, "add", add)
|
||
return errs.WrapMsg(err, "failed to unmarshal webhook config")
|
||
}
|
||
|
||
// 记录更新前的Enable状态
|
||
enableBefore := webhookConfig.AfterSendGroupMsg.Enable
|
||
|
||
// 验证解析后的配置是否有效
|
||
if webhookConfig.AfterSendGroupMsg.AttentionIds == nil {
|
||
webhookConfig.AfterSendGroupMsg.AttentionIds = []string{}
|
||
}
|
||
|
||
// 更新afterSendGroupMsg的attentionIds
|
||
attentionIds := webhookConfig.AfterSendGroupMsg.AttentionIds
|
||
oldCount := len(attentionIds)
|
||
var updated bool
|
||
|
||
if add {
|
||
// 添加groupID（如果不存在）
|
||
if !datautil.Contain(groupID, attentionIds...) {
|
||
attentionIds = append(attentionIds, groupID)
|
||
webhookConfig.AfterSendGroupMsg.AttentionIds = attentionIds
|
||
updated = true
|
||
log.ZInfo(ctx, "UpdateAttentionIds: adding groupID to attentionIds", "groupID", groupID, "old_count", oldCount, "new_count", len(attentionIds), "enable", enableBefore)
|
||
} else {
|
||
log.ZDebug(ctx, "UpdateAttentionIds: groupID already exists in attentionIds, skipping", "groupID", groupID, "count", oldCount)
|
||
return nil
|
||
}
|
||
} else {
|
||
// 移除groupID
|
||
newAttentionIds := make([]string, 0, len(attentionIds))
|
||
for _, id := range attentionIds {
|
||
if id != groupID {
|
||
newAttentionIds = append(newAttentionIds, id)
|
||
}
|
||
}
|
||
if len(newAttentionIds) != len(attentionIds) {
|
||
webhookConfig.AfterSendGroupMsg.AttentionIds = newAttentionIds
|
||
updated = true
|
||
log.ZInfo(ctx, "UpdateAttentionIds: removing groupID from attentionIds", "groupID", groupID, "old_count", oldCount, "new_count", len(newAttentionIds), "enable", enableBefore)
|
||
} else {
|
||
log.ZDebug(ctx, "UpdateAttentionIds: groupID not found in attentionIds, skipping", "groupID", groupID, "count", oldCount)
|
||
return nil
|
||
}
|
||
}
|
||
|
||
if !updated {
|
||
return nil
|
||
}
|
||
|
||
// 验证配置URL是否存在（必要的验证）
|
||
if webhookConfig.URL == "" {
|
||
log.ZWarn(ctx, "UpdateAttentionIds: webhook config URL is empty, skipping update", nil, "groupID", groupID, "add", add)
|
||
return errs.ErrArgs.WrapMsg("webhook config URL is empty")
|
||
}
|
||
|
||
// 记录更新后的Enable状态（确保没有被修改）
|
||
enableAfter := webhookConfig.AfterSendGroupMsg.Enable
|
||
if enableBefore != enableAfter {
|
||
log.ZWarn(ctx, "UpdateAttentionIds: Enable field changed unexpectedly", nil,
|
||
"groupID", groupID, "add", add,
|
||
"enable_before", enableBefore, "enable_after", enableAfter)
|
||
// 恢复原始值，确保不会修改Enable字段
|
||
webhookConfig.AfterSendGroupMsg.Enable = enableBefore
|
||
}
|
||
|
||
// 序列化更新后的配置（只更新attentionIds，不改变其他配置）
|
||
updatedValue, err := json.Marshal(webhookConfig)
|
||
if err != nil {
|
||
log.ZWarn(ctx, "UpdateAttentionIds: failed to marshal updated webhook config", err, "groupID", groupID, "add", add)
|
||
return errs.WrapMsg(err, "failed to marshal updated webhook config")
|
||
}
|
||
|
||
// 更新数据库
|
||
if err := db.Update(ctx, WebhookConfigKey, map[string]any{
|
||
"value": string(updatedValue),
|
||
}); err != nil {
|
||
log.ZWarn(ctx, "UpdateAttentionIds: failed to update webhook config in database", err, "groupID", groupID, "add", add)
|
||
return errs.WrapMsg(err, "failed to update webhook config in database")
|
||
}
|
||
|
||
log.ZInfo(ctx, "UpdateAttentionIds: successfully updated attentionIds in database",
|
||
"groupID", groupID, "add", add,
|
||
"attention_ids_count", len(webhookConfig.AfterSendGroupMsg.AttentionIds),
|
||
"enable", webhookConfig.AfterSendGroupMsg.Enable)
|
||
return nil
|
||
}
|