refactor: optimize event processor

alert/mute/mute.go

@@ -9,7 +9,6 @@ import (
 	"github.com/ccfos/nightingale/v6/memsto"
 	"github.com/ccfos/nightingale/v6/models"
 
-	"github.com/pkg/errors"
 	"github.com/toolkits/pkg/logger"
 )
 
@@ -136,8 +135,7 @@ func EventMuteStrategy(event *models.AlertCurEvent, alertMuteCache *memsto.Alert
 	}
 
 	for i := 0; i < len(mutes); i++ {
-		matched, _ := MatchMute(event, mutes[i])
-		if matched {
+		if MatchMute(event, mutes[i]) {
 			return true, mutes[i].Id
 		}
 	}
@@ -146,9 +144,9 @@ func EventMuteStrategy(event *models.AlertCurEvent, alertMuteCache *memsto.Alert
 }
 
 // MatchMute 如果传入了clock这个可选参数，就表示使用这个clock表示的时间，否则就从event的字段中取TriggerTime
-func MatchMute(event *models.AlertCurEvent, mute *models.AlertMute, clock ...int64) (bool, error) {
+func MatchMute(event *models.AlertCurEvent, mute *models.AlertMute, clock ...int64) bool {
 	if mute.Disabled == 1 {
-		return false, errors.New("mute is disabled")
+		return false
 	}
 
 	// 如果不是全局的，判断 匹配的 datasource id
@@ -160,13 +158,13 @@ func MatchMute(event *models.AlertCurEvent, mute *models.AlertMute, clock ...int
 
 		// 判断 event.datasourceId 是否包含在 idm 中
 		if _, has := idm[event.DatasourceId]; !has {
-			return false, errors.New("datasource id not match")
+			return false
 		}
 	}
 
 	if mute.MuteTimeType == models.TimeRange {
 		if !mute.IsWithinTimeRange(event.TriggerTime) {
-			return false, errors.New("event trigger time not within mute time range")
+			return false
 		}
 	} else if mute.MuteTimeType == models.Periodic {
 		ts := event.TriggerTime
@@ -175,11 +173,11 @@ func MatchMute(event *models.AlertCurEvent, mute *models.AlertMute, clock ...int
 		}
 
 		if !mute.IsWithinPeriodicMute(ts) {
-			return false, errors.New("event trigger time not within periodic mute range")
+			return false
 		}
 	} else {
 		logger.Warningf("mute time type invalid, %d", mute.MuteTimeType)
-		return false, errors.New("mute time type invalid")
+		return false
 	}
 
 	var matchSeverity bool
@@ -195,14 +193,12 @@ func MatchMute(event *models.AlertCurEvent, mute *models.AlertMute, clock ...int
 	}
 
 	if !matchSeverity {
-		return false, errors.New("event severity not match mute severity")
+		return false
 	}
 
 	if mute.ITags == nil || len(mute.ITags) == 0 {
-		return true, nil
+		return true
 	}
-	if !common.MatchTags(event.TagsMap, mute.ITags) {
-		return false, errors.New("event tags not match mute tags")
-	}
-	return true, nil
+
+	return common.MatchTags(event.TagsMap, mute.ITags)
 }

alert/pipeline/processor/eventdrop/event_drop.go

@@ -53,7 +53,7 @@ func (c *EventDropConfig) Process(ctx *ctx.Context, event *models.AlertCurEvent)
 	logger.Infof("processor eventdrop result: %v", result)
 	if result == "true" {
 		logger.Infof("processor eventdrop drop event: %v", event)
-		return nil, "drop event success", nil
+		return event, "drop event success", nil
 	}
 
 	return event, "drop event failed", nil

center/router/router.go

@@ -254,7 +254,6 @@ func (rt *Router) Config(r *gin.Engine) {
 
 		pages.GET("/notify-channels", rt.notifyChannelsGets)
 		pages.GET("/contact-keys", rt.contactKeysGets)
-		pages.GET("/install-date", rt.installDateGet)
 
 		pages.GET("/self/perms", rt.auth(), rt.user(), rt.permsGets)
 		pages.GET("/self/profile", rt.auth(), rt.user(), rt.selfProfileGet)
@@ -373,8 +372,6 @@ func (rt *Router) Config(r *gin.Engine) {
 		pages.POST("/relabel-test", rt.auth(), rt.user(), rt.relabelTest)
 		pages.POST("/busi-group/:id/alert-rules/clone", rt.auth(), rt.user(), rt.perm("/alert-rules/add"), rt.bgrw(), rt.cloneToMachine)
 		pages.POST("/busi-groups/alert-rules/clones", rt.auth(), rt.user(), rt.perm("/alert-rules/add"), rt.batchAlertRuleClone)
-		pages.POST("/busi-group/alert-rules/notify-tryrun", rt.auth(), rt.user(), rt.perm("/alert-rules/add"), rt.alertRuleNotifyTryRun)
-		pages.POST("/busi-group/alert-rules/enable-tryrun", rt.auth(), rt.user(), rt.perm("/alert-rules/add"), rt.alertRuleEnableTryRun)
 
 		pages.GET("/busi-groups/recording-rules", rt.auth(), rt.user(), rt.perm("/recording-rules"), rt.recordingRuleGetsByGids)
 		pages.GET("/busi-group/:id/recording-rules", rt.auth(), rt.user(), rt.perm("/recording-rules"), rt.recordingRuleGets)
@@ -400,7 +397,6 @@ func (rt *Router) Config(r *gin.Engine) {
 		pages.POST("/busi-group/:id/alert-subscribes", rt.auth(), rt.user(), rt.perm("/alert-subscribes/add"), rt.bgrw(), rt.alertSubscribeAdd)
 		pages.PUT("/busi-group/:id/alert-subscribes", rt.auth(), rt.user(), rt.perm("/alert-subscribes/put"), rt.bgrw(), rt.alertSubscribePut)
 		pages.DELETE("/busi-group/:id/alert-subscribes", rt.auth(), rt.user(), rt.perm("/alert-subscribes/del"), rt.bgrw(), rt.alertSubscribeDel)
-		pages.POST("/alert-subscribe/alert-subscribes-tryrun", rt.auth(), rt.user(), rt.perm("/alert-subscribes/add"), rt.alertSubscribeTryRun)
 
 		pages.GET("/alert-cur-event/:eid", rt.alertCurEventGet)
 		pages.GET("/alert-his-event/:eid", rt.alertHisEventGet)

center/router/router_alert_rule.go

@@ -11,7 +11,6 @@ import (
 
 	"gopkg.in/yaml.v2"
 
-	"github.com/ccfos/nightingale/v6/alert/mute"
 	"github.com/ccfos/nightingale/v6/models"
 	"github.com/ccfos/nightingale/v6/pkg/strx"
 	"github.com/ccfos/nightingale/v6/pushgw/pconf"
@@ -19,7 +18,6 @@ import (
 
 	"github.com/gin-gonic/gin"
 	"github.com/jinzhu/copier"
-	"github.com/pkg/errors"
 	"github.com/prometheus/prometheus/prompb"
 	"github.com/toolkits/pkg/ginx"
 	"github.com/toolkits/pkg/i18n"
@@ -159,120 +157,6 @@ func (rt *Router) alertRuleAddByFE(c *gin.Context) {
 	ginx.NewRender(c).Data(reterr, nil)
 }
 
-type AlertRuleTryRunForm struct {
-	EventId         int64            `json:"event_id" binding:"required"`
-	AlertRuleConfig models.AlertRule `json:"alert_rule_config" binding:"required"`
-}
-
-func (rt *Router) alertRuleNotifyTryRun(c *gin.Context) {
-	// check notify channels of old version
-	var f AlertRuleTryRunForm
-	ginx.BindJSON(c, &f)
-
-	hisEvent, err := models.AlertHisEventGetById(rt.Ctx, f.EventId)
-	ginx.Dangerous(err)
-
-	if hisEvent == nil {
-		ginx.Bomb(http.StatusNotFound, "event not found")
-	}
-
-	curEvent := *hisEvent.ToCur()
-	curEvent.SetTagsMap()
-
-	if f.AlertRuleConfig.NotifyVersion == 1 {
-		for _, id := range f.AlertRuleConfig.NotifyRuleIds {
-			notifyRule, err := models.GetNotifyRule(rt.Ctx, id)
-			ginx.Dangerous(err)
-			for _, notifyConfig := range notifyRule.NotifyConfigs {
-				_, err = SendNotifyChannelMessage(rt.Ctx, rt.UserCache, rt.UserGroupCache, notifyConfig, []*models.AlertCurEvent{&curEvent})
-				ginx.Dangerous(err)
-			}
-		}
-
-		ginx.NewRender(c).Data("notification test ok", nil)
-		return
-	}
-
-	if len(f.AlertRuleConfig.NotifyChannelsJSON) == 0 {
-		ginx.Bomb(http.StatusOK, "no notify channels selected")
-	}
-
-	if len(f.AlertRuleConfig.NotifyGroupsJSON) == 0 {
-		ginx.Bomb(http.StatusOK, "no notify groups selected")
-	}
-
-	ancs := make([]string, 0, len(curEvent.NotifyChannelsJSON))
-	ugids := f.AlertRuleConfig.NotifyGroupsJSON
-	ngids := make([]int64, 0)
-	for i := 0; i < len(ugids); i++ {
-		if gid, err := strconv.ParseInt(ugids[i], 10, 64); err == nil {
-			ngids = append(ngids, gid)
-		}
-	}
-	userGroups := rt.UserGroupCache.GetByUserGroupIds(ngids)
-	uids := make([]int64, 0)
-	for i := range userGroups {
-		uids = append(uids, userGroups[i].UserIds...)
-	}
-	users := rt.UserCache.GetByUserIds(uids)
-	for _, NotifyChannels := range curEvent.NotifyChannelsJSON {
-		flag := true
-		// ignore non-default channels
-		switch NotifyChannels {
-		case models.Dingtalk, models.Wecom, models.Feishu, models.Mm,
-			models.Telegram, models.Email, models.FeishuCard:
-			// do nothing
-		default:
-			continue
-		}
-		// default channels
-		for ui := range users {
-			if _, b := users[ui].ExtractToken(NotifyChannels); b {
-				flag = false
-				break
-			}
-		}
-		if flag {
-			ancs = append(ancs, NotifyChannels)
-		}
-	}
-	if len(ancs) > 0 {
-		ginx.Dangerous(errors.New(fmt.Sprintf("All users are missing notify channel configurations. Please check for missing tokens (each channel should be configured with at least one user). %v", ancs)))
-	}
-
-	ginx.NewRender(c).Data("notification test ok", nil)
-}
-
-func (rt *Router) alertRuleEnableTryRun(c *gin.Context) {
-	// check notify channels of old version
-	var f AlertRuleTryRunForm
-	ginx.BindJSON(c, &f)
-
-	hisEvent, err := models.AlertHisEventGetById(rt.Ctx, f.EventId)
-	ginx.Dangerous(err)
-
-	if hisEvent == nil {
-		ginx.Bomb(http.StatusNotFound, "event not found")
-	}
-
-	curEvent := *hisEvent.ToCur()
-	curEvent.SetTagsMap()
-
-	if f.AlertRuleConfig.Disabled == 1 {
-		ginx.Bomb(http.StatusOK, "rule is disabled")
-	}
-
-	if mute.TimeSpanMuteStrategy(&f.AlertRuleConfig, &curEvent) {
-		ginx.Bomb(http.StatusOK, "event is not match for period of time")
-	}
-
-	if mute.BgNotMatchMuteStrategy(&f.AlertRuleConfig, &curEvent, rt.TargetCache) {
-		ginx.Bomb(http.StatusOK, "event target busi group not match rule busi group")
-	}
-
-	ginx.NewRender(c).Data("event is effective", nil)
-}
-
 func (rt *Router) alertRuleAddByImport(c *gin.Context) {
 	username := c.MustGet("username").(string)
 

center/router/router_alert_subscribe.go

@@ -1,18 +1,13 @@
 package router
 
 import (
-	"fmt"
 	"net/http"
-	"strconv"
-	"strings"
 	"time"
 
-	"github.com/ccfos/nightingale/v6/alert/common"
 	"github.com/ccfos/nightingale/v6/models"
 	"github.com/ccfos/nightingale/v6/pkg/strx"
 
 	"github.com/gin-gonic/gin"
-	"github.com/pkg/errors"
 	"github.com/toolkits/pkg/ginx"
 )
 
@@ -109,124 +104,6 @@ func (rt *Router) alertSubscribeAdd(c *gin.Context) {
 	ginx.NewRender(c).Message(f.Add(rt.Ctx))
 }
 
-type SubscribeTryRunForm struct {
-	EventId         int64                 `json:"event_id" binding:"required"`
-	SubscribeConfig models.AlertSubscribe `json:"subscribe_config" binding:"required"`
-}
-
-func (rt *Router) alertSubscribeTryRun(c *gin.Context) {
-	var f SubscribeTryRunForm
-	ginx.BindJSON(c, &f)
-
-	hisEvent, err := models.AlertHisEventGetById(rt.Ctx, f.EventId)
-	ginx.Dangerous(err)
-
-	if hisEvent == nil {
-		ginx.Bomb(http.StatusNotFound, "event not found")
-	}
-
-	curEvent := *hisEvent.ToCur()
-	curEvent.SetTagsMap()
-
-	// 先判断匹配条件
-	if !f.SubscribeConfig.MatchCluster(curEvent.DatasourceId) {
-		ginx.Dangerous(errors.New("Datasource mismatch"))
-	}
-
-	// 匹配 tag
-	f.SubscribeConfig.Parse()
-	if !common.MatchTags(curEvent.TagsMap, f.SubscribeConfig.ITags) {
-		ginx.Dangerous(errors.New("Tags mismatch"))
-	}
-
-	// 匹配group name
-	if !common.MatchGroupsName(curEvent.GroupName, f.SubscribeConfig.IBusiGroups) {
-		ginx.Dangerous(errors.New("Group name mismatch"))
-	}
-
-	// 检查严重级别（Severity）匹配
-	if len(f.SubscribeConfig.SeveritiesJson) != 0 {
-		match := false
-		for _, s := range f.SubscribeConfig.SeveritiesJson {
-			if s == curEvent.Severity || s == 0 {
-				match = true
-				break
-			}
-		}
-		if !match {
-			ginx.Dangerous(errors.New("Severity mismatch"))
-		}
-	}
-
-	// 新版本通知规则
-	if f.SubscribeConfig.NotifyVersion == 1 {
-		for _, id := range f.SubscribeConfig.NotifyRuleIds {
-			notifyRule, err := models.GetNotifyRule(rt.Ctx, id)
-			ginx.Dangerous(err)
-
-			for _, notifyConfig := range notifyRule.NotifyConfigs {
-				_, err = SendNotifyChannelMessage(rt.Ctx, rt.UserCache, rt.UserGroupCache, notifyConfig, []*models.AlertCurEvent{&curEvent})
-				ginx.Dangerous(err)
-			}
-		}
-
-		ginx.NewRender(c).Data("notification test ok", nil)
-		return
-	}
-
-	// 旧版通知方式
-	f.SubscribeConfig.ModifyEvent(&curEvent)
-	if len(curEvent.NotifyChannelsJSON) == 0 {
-		ginx.Bomb(http.StatusBadRequest, "no notify channels selected")
-	}
-
-	if len(curEvent.NotifyGroupsJSON) == 0 {
-		ginx.Bomb(http.StatusOK, "no notify groups selected")
-	}
-
-	ancs := make([]string, 0, len(curEvent.NotifyChannelsJSON))
-	ugids := strings.Fields(f.SubscribeConfig.UserGroupIds)
-	ngids := make([]int64, 0)
-	for i := 0; i < len(ugids); i++ {
-		if gid, err := strconv.ParseInt(ugids[i], 10, 64); err == nil {
-			ngids = append(ngids, gid)
-		}
-	}
-
-	userGroups := rt.UserGroupCache.GetByUserGroupIds(ngids)
-	uids := make([]int64, 0)
-	for i := range userGroups {
-		uids = append(uids, userGroups[i].UserIds...)
-	}
-	users := rt.UserCache.GetByUserIds(uids)
-	for _, NotifyChannels := range curEvent.NotifyChannelsJSON {
-		flag := true
-		// ignore non-default channels
-		switch NotifyChannels {
-		case models.Dingtalk, models.Wecom, models.Feishu, models.Mm,
-			models.Telegram, models.Email, models.FeishuCard:
-			// do nothing
-		default:
-			continue
-		}
-		// default channels
-		for ui := range users {
-			if _, b := users[ui].ExtractToken(NotifyChannels); b {
-				flag = false
-				break
-			}
-		}
-		if flag {
-			ancs = append(ancs, NotifyChannels)
-		}
-	}
-	if len(ancs) > 0 {
-		ginx.Dangerous(errors.New(fmt.Sprintf("All users are missing notify channel configurations. Please check for missing tokens (each channel should be configured with at least one user). %v", ancs)))
-	}
-
-	ginx.NewRender(c).Data("notification test ok", nil)
-}
-
 func (rt *Router) alertSubscribePut(c *gin.Context) {
 	var fs []models.AlertSubscribe
 	ginx.BindJSON(c, &fs)

center/router/router_event_pipeline.go

@@ -158,11 +158,7 @@ func (rt *Router) tryRunEventPipeline(c *gin.Context) {
 		}
 	}
 
-	m := map[string]interface{}{
-		"event":  event,
-		"result": "",
-	}
-	ginx.NewRender(c).Data(m, nil)
+	ginx.NewRender(c).Data(event, nil)
 }
 
 // 测试事件处理器
@@ -181,11 +177,11 @@ func (rt *Router) tryRunEventProcessor(c *gin.Context) {
 
 	processor, err := models.GetProcessorByType(f.ProcessorConfig.Typ, f.ProcessorConfig.Config)
 	if err != nil {
-		ginx.Bomb(200, "get processor err: %+v", err)
+		ginx.Bomb(http.StatusBadRequest, "get processor err: %+v", err)
 	}
 	event, res, err := processor.Process(rt.Ctx, event)
 	if err != nil {
-		ginx.Bomb(200, "processor err: %+v", err)
+		ginx.Bomb(http.StatusBadRequest, "processor err: %+v", err)
 	}
 
 	ginx.NewRender(c).Data(map[string]interface{}{

center/router/router_mute.go

@@ -95,9 +95,7 @@ func (rt *Router) alertMuteTryRun(c *gin.Context) {
 	f.AlertMute.Btime = 0             // 最小可能值（如 Unix 时间戳起点）
 	f.AlertMute.Etime = math.MaxInt64 // 最大可能值（int64 上限）
 
-	match, err := mute.MatchMute(&curEvent, &f.AlertMute)
-	ginx.Dangerous(err)
-	if !match {
+	if !mute.MatchMute(&curEvent, &f.AlertMute) {
 		ginx.NewRender(c).Data("not match", nil)
 		return
 	}

center/router/router_notify_rule.go

@@ -6,12 +6,11 @@ import (
 	"time"
 
 	"github.com/ccfos/nightingale/v6/alert/dispatch"
-	"github.com/ccfos/nightingale/v6/memsto"
 	"github.com/ccfos/nightingale/v6/models"
-	"github.com/ccfos/nightingale/v6/pkg/ctx"
 	"github.com/ccfos/nightingale/v6/pkg/slice"
 
 	"github.com/gin-gonic/gin"
+	"github.com/pkg/errors"
 	"github.com/toolkits/pkg/ginx"
 	"github.com/toolkits/pkg/logger"
 )
@@ -162,89 +161,79 @@ func (rt *Router) notifyTest(c *gin.Context) {
 		ginx.Bomb(http.StatusBadRequest, "not events applicable")
 	}
 
-	resp, err := SendNotifyChannelMessage(rt.Ctx, rt.UserCache, rt.UserGroupCache, f.NotifyConfig, events)
-	ginx.NewRender(c).Data(resp, err)
-}
-
-func SendNotifyChannelMessage(ctx *ctx.Context, userCache *memsto.UserCacheType, userGroup *memsto.UserGroupCacheType, notifyConfig models.NotifyConfig, events []*models.AlertCurEvent) (string, error) {
-	notifyChannels, err := models.NotifyChannelGets(ctx, notifyConfig.ChannelID, "", "", -1)
-	if err != nil {
-		return "", fmt.Errorf("failed to get notify channels: %v", err)
-	}
-
+	notifyChannels, err := models.NotifyChannelGets(rt.Ctx, f.NotifyConfig.ChannelID, "", "", -1)
+	ginx.Dangerous(err)
 	if len(notifyChannels) == 0 {
-		return "", fmt.Errorf("notify channel not found")
+		ginx.Bomb(http.StatusBadRequest, "notify channel not found")
 	}
 
 	notifyChannel := notifyChannels[0]
-	if !notifyChannel.Enable {
-		return "", fmt.Errorf("notify channel not enabled, please enable it first")
-	}
-	tplContent := make(map[string]interface{})
-	if notifyChannel.RequestType != "flashduty" {
-		messageTemplates, err := models.MessageTemplateGets(ctx, notifyConfig.TemplateID, "", "")
-		if err != nil {
-			return "", fmt.Errorf("failed to get message templates: %v", err)
-		}
 
+	if !notifyChannel.Enable {
+		ginx.Bomb(http.StatusBadRequest, "notify channel not enabled, please enable it first")
+	}
+
+	tplContent := make(map[string]interface{})
+	if notifyChannel.RequestType != "flashtudy" {
+		messageTemplates, err := models.MessageTemplateGets(rt.Ctx, f.NotifyConfig.TemplateID, "", "")
+		ginx.Dangerous(err)
 		if len(messageTemplates) == 0 {
-			return "", fmt.Errorf("message template not found")
+			ginx.Bomb(http.StatusBadRequest, "message template not found")
 		}
 		tplContent = messageTemplates[0].RenderEvent(events)
 	}
+
 	var contactKey string
 	if notifyChannel.ParamConfig != nil && notifyChannel.ParamConfig.UserInfo != nil {
 		contactKey = notifyChannel.ParamConfig.UserInfo.ContactKey
 	}
 
-	sendtos, flashDutyChannelIDs, customParams := dispatch.GetNotifyConfigParams(&notifyConfig, contactKey, userCache, userGroup)
+	sendtos, flashDutyChannelIDs, customParams := dispatch.GetNotifyConfigParams(&f.NotifyConfig, contactKey, rt.UserCache, rt.UserGroupCache)
 
 	var resp string
 	switch notifyChannel.RequestType {
 	case "flashduty":
 		client, err := models.GetHTTPClient(notifyChannel)
-		if err != nil {
-			return "", fmt.Errorf("failed to get http client: %v", err)
-		}
+		ginx.Dangerous(err)
 
 		for i := range flashDutyChannelIDs {
 			resp, err = notifyChannel.SendFlashDuty(events, flashDutyChannelIDs[i], client)
 			if err != nil {
-				return "", fmt.Errorf("failed to send flashduty notify: %v", err)
+				break
 			}
 		}
 		logger.Infof("channel_name: %v, event:%+v, tplContent:%s, customParams:%v, respBody: %v, err: %v", notifyChannel.Name, events[0], tplContent, customParams, resp, err)
-		return resp, nil
+		ginx.NewRender(c).Data(resp, err)
 	case "http":
 		client, err := models.GetHTTPClient(notifyChannel)
-		if err != nil {
-			return "", fmt.Errorf("failed to get http client: %v", err)
-		}
+		ginx.Dangerous(err)
 
 		if notifyChannel.RequestConfig == nil {
-			return "", fmt.Errorf("request config is nil")
+			ginx.Bomb(http.StatusBadRequest, "request config not found")
 		}
 
 		if notifyChannel.RequestConfig.HTTPRequestConfig == nil {
-			return "", fmt.Errorf("http request config is nil")
+			ginx.Bomb(http.StatusBadRequest, "http request config not found")
 		}
 
 		if dispatch.NeedBatchContacts(notifyChannel.RequestConfig.HTTPRequestConfig) || len(sendtos) == 0 {
 			resp, err = notifyChannel.SendHTTP(events, tplContent, customParams, sendtos, client)
 			logger.Infof("channel_name: %v, event:%+v, sendtos:%+v, tplContent:%s, customParams:%v, respBody: %v, err: %v", notifyChannel.Name, events[0], sendtos, tplContent, customParams, resp, err)
 			if err != nil {
-				return "", fmt.Errorf("failed to send http notify: %v", err)
+				logger.Errorf("failed to send http notify: %v", err)
 			}
-			return resp, nil
+			ginx.NewRender(c).Data(resp, err)
 		} else {
 			for i := range sendtos {
 				resp, err = notifyChannel.SendHTTP(events, tplContent, customParams, []string{sendtos[i]}, client)
 				logger.Infof("channel_name: %v, event:%+v,  tplContent:%s, customParams:%v, sendto:%+v, respBody: %v, err: %v", notifyChannel.Name, events[0], tplContent, customParams, sendtos[i], resp, err)
 				if err != nil {
-					return "", fmt.Errorf("failed to send http notify: %v", err)
+					logger.Errorf("failed to send http notify: %v", err)
+					ginx.NewRender(c).Message(err)
+					return
 				}
 			}
-			return resp, nil
+			ginx.NewRender(c).Message(err)
 		}
 
 	case "smtp":
@@ -252,17 +241,14 @@ func SendNotifyChannelMessage(ctx *ctx.Context, userCache *memsto.UserCacheType,
 			ginx.Bomb(http.StatusBadRequest, "No valid email address in the user and team")
 		}
 		err := notifyChannel.SendEmailNow(events, tplContent, sendtos)
-		if err != nil {
-			return "", fmt.Errorf("failed to send email notify: %v", err)
-		}
-		return resp, nil
+		ginx.NewRender(c).Message(err)
 	case "script":
 		resp, _, err := notifyChannel.SendScript(events, tplContent, customParams, sendtos)
 		logger.Infof("channel_name: %v, event:%+v, tplContent:%s, customParams:%v, respBody: %v, err: %v", notifyChannel.Name, events[0], tplContent, customParams, resp, err)
-		return resp, err
+		ginx.NewRender(c).Data(resp, err)
 	default:
 		logger.Errorf("unsupported request type: %v", notifyChannel.RequestType)
-		return "", fmt.Errorf("unsupported request type")
+		ginx.NewRender(c).Message(errors.New("unsupported request type"))
 	}
 }
 

center/router/router_user.go

@@ -235,20 +235,3 @@ func (rt *Router) userDel(c *gin.Context) {
 
 	ginx.NewRender(c).Message(target.Del(rt.Ctx))
 }
-
-func (rt *Router) installDateGet(c *gin.Context) {
-	rootUser, err := models.UserGetByUsername(rt.Ctx, "root")
-	if err != nil {
-		logger.Errorf("get root user failed: %v", err)
-		ginx.NewRender(c).Data(0, nil)
-		return
-	}
-
-	if rootUser == nil {
-		logger.Errorf("root user not found")
-		ginx.NewRender(c).Data(0, nil)
-		return
-	}
-
-	ginx.NewRender(c).Data(rootUser.CreateAt, nil)
-}

conf/crypto.go

@@ -14,13 +14,6 @@ func decryptConfig(config *ConfigType, cryptoKey string) error {
 
 	config.DB.DSN = decryptDsn
 
-	decryptRedisPwd, err := secu.DealWithDecrypt(config.Redis.Password, cryptoKey)
-	if err != nil {
-		return fmt.Errorf("failed to decrypt the redis password: %s", err)
-	}
-
-	config.Redis.Password = decryptRedisPwd
-
 	for k := range config.HTTP.APIForService.BasicAuth {
 		decryptPwd, err := secu.DealWithDecrypt(config.HTTP.APIForService.BasicAuth[k], cryptoKey)
 		if err != nil {

go.mod

@@ -27,7 +27,7 @@ require (
 	github.com/jinzhu/copier v0.4.0
 	github.com/json-iterator/go v1.1.12
 	github.com/koding/multiconfig v0.0.0-20171124222453-69c27309b2d7
-	github.com/lib/pq v1.10.9
+	github.com/lib/pq v1.0.0
 	github.com/mailru/easyjson v0.7.7
 	github.com/mattn/go-isatty v0.0.19
 	github.com/mitchellh/mapstructure v1.5.0

go.sum

@@ -220,8 +220,8 @@ github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+
 github.com/leodido/go-urn v1.2.1/go.mod h1:zt4jvISO2HfUBqxjfIshjdMTYS56ZS/qv49ictyFfxY=
 github.com/leodido/go-urn v1.2.4 h1:XlAE/cm/ms7TE/VMVoduSpNBoyc2dOxHs5MZSwAN63Q=
 github.com/leodido/go-urn v1.2.4/go.mod h1:7ZrI8mTSeBSHl/UaRyKQW1qZeMgak41ANeCNaVckg+4=
-github.com/lib/pq v1.10.9 h1:YXG7RB+JIjhP29X+OtkiDnYaXQwpS4JEWq7dtCCRUEw=
-github.com/lib/pq v1.10.9/go.mod h1:AlVN5x4E4T544tWzH6hKfbfQvm3HdbOxrmggDNAPY9o=
+github.com/lib/pq v1.0.0 h1:X5PMW56eZitiTeO7tKzZxFCSpbFZJtkMMooicw2us9A=
+github.com/lib/pq v1.0.0/go.mod h1:5WUZQaWbwv1U+lTReE5YruASi9Al49XbQIvNi/34Woo=
 github.com/mailru/easyjson v0.7.7 h1:UGYAvKxe3sBsEDzO8ZeWOSlIQfWFlxbzLZe7hwFURr0=
 github.com/mailru/easyjson v0.7.7/go.mod h1:xzfreul335JAWq5oZzymOObrkdz5UnU4kGfJJLY9Nlc=
 github.com/mattn/go-isatty v0.0.14/go.mod h1:7GGIvUiUoEMVVmxf/4nioHXj79iQHKdU27kJ6hsGG94=

pkg/ginx/auth.go

@@ -1,102 +0,0 @@
-// Copyright 2014 Manu Martinez-Almeida. All rights reserved.
-// Use of this source code is governed by a MIT style
-// license that can be found in the LICENSE file.
-
-package ginx
-
-import (
-	"crypto/subtle"
-	"encoding/base64"
-	"net/http"
-	"strconv"
-
-	"github.com/gin-gonic/gin"
-)
-
-// AuthUserKey is the cookie name for user credential in basic auth.
-const AuthUserKey = "user"
-
-// Accounts defines a key/value for user/pass list of authorized logins.
-type Accounts []Account
-
-type Account struct {
-	User     string
-	Password string
-}
-
-type authPair struct {
-	value string
-	user  string
-}
-
-type authPairs []authPair
-
-func (a authPairs) searchCredential(authValue string) (string, bool) {
-	if authValue == "" {
-		return "", false
-	}
-	for _, pair := range a {
-		if subtle.ConstantTimeCompare(StringToBytes(pair.value), StringToBytes(authValue)) == 1 {
-			return pair.user, true
-		}
-	}
-	return "", false
-}
-
-// BasicAuthForRealm returns a Basic HTTP Authorization middleware. It takes as arguments a map[string]string where
-// the key is the user name and the value is the password, as well as the name of the Realm.
-// If the realm is empty, "Authorization Required" will be used by default.
-// (see http://tools.ietf.org/html/rfc2617#section-1.2)
-func BasicAuthForRealm(accounts Accounts, realm string) gin.HandlerFunc {
-	if realm == "" {
-		realm = "Authorization Required"
-	}
-	realm = "Basic realm=" + strconv.Quote(realm)
-	pairs := processAccounts(accounts)
-	return func(c *gin.Context) {
-		// Search user in the slice of allowed credentials
-		user, found := pairs.searchCredential(c.Request.Header.Get("Authorization"))
-		if !found {
-			// Credentials doesn't match, we return 401 and abort handlers chain.
-			c.Header("WWW-Authenticate", realm)
-			c.AbortWithStatus(http.StatusUnauthorized)
-			return
-		}
-
-		// The user credentials was found, set user's id to key AuthUserKey in this context, the user's id can be read later using
-		// c.MustGet(gin.AuthUserKey).
-		c.Set(AuthUserKey, user)
-	}
-}
-
-// BasicAuth returns a Basic HTTP Authorization middleware. It takes as argument a map[string]string where
-// the key is the user name and the value is the password.
-func BasicAuth(accounts Accounts) gin.HandlerFunc {
-	return BasicAuthForRealm(accounts, "")
-}
-
-func processAccounts(accounts Accounts) authPairs {
-	length := len(accounts)
-	assert1(length > 0, "Empty list of authorized credentials")
-	pairs := make(authPairs, 0, length)
-	for _, account := range accounts {
-		assert1(account.User != "", "User can not be empty")
-		value := authorizationHeader(account.User, account.Password)
-		pairs = append(pairs, authPair{
-			value: value,
-			user:  account.User,
-		})
-	}
-	return pairs
-}
-
-func authorizationHeader(user, password string) string {
-	base := user + ":" + password
-	return "Basic " + base64.StdEncoding.EncodeToString(StringToBytes(base))
-}
-
-func assert1(guard bool, text string) {
-	if !guard {
-		panic(text)
-	}
-}

pkg/ginx/bytesconv.go

@@ -1,23 +0,0 @@
-// Copyright 2023 Gin Core Team. All rights reserved.
-// Use of this source code is governed by a MIT style
-// license that can be found in the LICENSE file.
-
-//go:build go1.20
-
-package ginx
-
-import (
-	"unsafe"
-)
-
-// StringToBytes converts string to byte slice without a memory allocation.
-// For more details, see https://github.com/golang/go/issues/53003#issuecomment-1140276077.
-func StringToBytes(s string) []byte {
-	return unsafe.Slice(unsafe.StringData(s), len(s))
-}
-
-// BytesToString converts byte slice to string without a memory allocation.
-// For more details, see https://github.com/golang/go/issues/53003#issuecomment-1140276077.
-func BytesToString(b []byte) string {
-	return unsafe.String(unsafe.SliceData(b), len(b))
-}

pushgw/router/router.go

@@ -6,13 +6,11 @@ import (
 
 	"github.com/gin-gonic/gin"
 	"github.com/prometheus/prometheus/prompb"
-	"github.com/toolkits/pkg/logger"
 
 	"github.com/ccfos/nightingale/v6/alert/aconf"
 	"github.com/ccfos/nightingale/v6/center/metas"
 	"github.com/ccfos/nightingale/v6/memsto"
 	"github.com/ccfos/nightingale/v6/pkg/ctx"
-	"github.com/ccfos/nightingale/v6/pkg/ginx"
 	"github.com/ccfos/nightingale/v6/pkg/httpx"
 	"github.com/ccfos/nightingale/v6/pushgw/idents"
 	"github.com/ccfos/nightingale/v6/pushgw/pconf"
@@ -88,22 +86,15 @@ func (rt *Router) Config(r *gin.Engine) {
 
 	if len(rt.HTTP.APIForAgent.BasicAuth) > 0 {
 		// enable basic auth
-		accounts := make(ginx.Accounts, 0)
+		accounts := make(gin.Accounts)
 		for username, password := range rt.HTTP.APIForAgent.BasicAuth {
-			accounts = append(accounts, ginx.Account{
-				User:     username,
-				Password: password,
-			})
+			accounts[username] = password
 		}
-
 		for username, password := range rt.HTTP.APIForService.BasicAuth {
-			accounts = append(accounts, ginx.Account{
-				User:     username,
-				Password: password,
-			})
+			accounts[username] = password
 		}
 
-		auth := ginx.BasicAuth(accounts)
+		auth := gin.BasicAuth(accounts)
 		r.POST("/opentsdb/put", auth, rt.openTSDBPut)
 		r.POST("/openfalcon/push", auth, rt.falconPush)
 		r.POST("/prometheus/v1/write", auth, rt.remoteWrite)