## Contact us and feedback questions
-- We recommend that you use [github issue](https://github.com/didi/nightingale/issues) as the preferred channel for issue feedback and requirement submission;
+- We recommend that you use [github issue](https://github.com/ccfos/nightingale/issues) as the preferred channel for issue feedback and requirement submission;
- You can join our WeChat group
@@ -57,12 +57,12 @@ Nightingale is an cloud-native monitoring system by All-In-On design, support en
## Contributing
We welcome your participation in the Nightingale open source project and open source community in a variety of ways:
-- Feedback on problems and bugs => [github issue](https://github.com/didi/nightingale/issues)
+- Feedback on problems and bugs => [github issue](https://github.com/ccfos/nightingale/issues)
- Additional and improved documentation => [n9e.github.io](https://n9e.github.io/)
-- Share your best practices and insights on using Nightingale => [User Story](https://github.com/didi/nightingale/issues/897)
-- Join our community events => [Nightingale wechat group](https://s3-gz01.didistatic.com/n9e-pub/image/n9e-wx.png)
-- Submit code to make Nightingale better =>[github PR](https://github.com/didi/nightingale/pulls)
+- Share your best practices and insights on using Nightingale => [User Story](https://github.com/ccfos/nightingale/issues/897)
+- Join our community events => [Nightingale wechat group](https://s3-gz01.ccfosstatic.com/n9e-pub/image/n9e-wx.png)
+- Submit code to make Nightingale better =>[github PR](https://github.com/ccfos/nightingale/pulls)
## License
-Nightingale with [Apache License V2.0](https://github.com/didi/nightingale/blob/main/LICENSE) open source license.
+Nightingale with [Apache License V2.0](https://github.com/ccfos/nightingale/blob/main/LICENSE) open source license.
diff --git a/alert/aconf/conf.go b/alert/aconf/conf.go
new file mode 100644
index 0000000000000000000000000000000000000000..68fcde54e0927bd6c4b5085c79b757ac6644f80a
--- /dev/null
+++ b/alert/aconf/conf.go
@@ -0,0 +1,71 @@
+package aconf
+
+import (
+ "path"
+
+ "github.com/toolkits/pkg/runner"
+)
+
+type Alert struct {
+ EngineDelay int64
+ Heartbeat HeartbeatConfig
+ Alerting Alerting
+ SMTP SMTPConfig
+ Ibex Ibex
+}
+
+type SMTPConfig struct {
+ Host string
+ Port int
+ User string
+ Pass string
+ From string
+ InsecureSkipVerify bool
+ Batch int
+}
+
+type HeartbeatConfig struct {
+ IP string
+ Interval int64
+ Endpoint string
+ ClusterName string
+}
+
+type Alerting struct {
+ Timeout int64
+ TemplatesDir string
+ NotifyConcurrency int
+}
+
+type CallPlugin struct {
+ Enable bool
+ PluginPath string
+ Caller string
+}
+
+type RedisPub struct {
+ Enable bool
+ ChannelPrefix string
+ ChannelKey string
+}
+
+type Ibex struct {
+ Address string
+ BasicAuthUser string
+ BasicAuthPass string
+ Timeout int64
+}
+
+func (a *Alert) PreCheck() {
+ if a.Alerting.TemplatesDir == "" {
+ a.Alerting.TemplatesDir = path.Join(runner.Cwd, "etc", "template")
+ }
+
+ if a.Alerting.Timeout == 0 {
+ a.Alerting.Timeout = 30000
+ }
+
+ if a.Heartbeat.Interval == 0 {
+ a.Heartbeat.Interval = 1000
+ }
+}
diff --git a/alert/alert.go b/alert/alert.go
new file mode 100644
index 0000000000000000000000000000000000000000..34a1e9dc50fabde39d67af129a604a1a60192a8f
--- /dev/null
+++ b/alert/alert.go
@@ -0,0 +1,99 @@
+package alert
+
+import (
+ "context"
+ "fmt"
+
+ "github.com/ccfos/nightingale/v6/alert/aconf"
+ "github.com/ccfos/nightingale/v6/alert/astats"
+ "github.com/ccfos/nightingale/v6/alert/dispatch"
+ "github.com/ccfos/nightingale/v6/alert/eval"
+ "github.com/ccfos/nightingale/v6/alert/naming"
+ "github.com/ccfos/nightingale/v6/alert/process"
+ "github.com/ccfos/nightingale/v6/alert/queue"
+ "github.com/ccfos/nightingale/v6/alert/record"
+ "github.com/ccfos/nightingale/v6/alert/router"
+ "github.com/ccfos/nightingale/v6/alert/sender"
+ "github.com/ccfos/nightingale/v6/conf"
+ "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/httpx"
+ "github.com/ccfos/nightingale/v6/pkg/logx"
+ "github.com/ccfos/nightingale/v6/prom"
+ "github.com/ccfos/nightingale/v6/pushgw/pconf"
+ "github.com/ccfos/nightingale/v6/pushgw/writer"
+ "github.com/ccfos/nightingale/v6/storage"
+)
+
+func Initialize(configDir string, cryptoKey string) (func(), error) {
+ config, err := conf.InitConfig(configDir, cryptoKey)
+ if err != nil {
+ return nil, fmt.Errorf("failed to init config: %v", err)
+ }
+
+ logxClean, err := logx.Init(config.Log)
+ if err != nil {
+ return nil, err
+ }
+
+ db, err := storage.New(config.DB)
+ if err != nil {
+ return nil, err
+ }
+ ctx := ctx.NewContext(context.Background(), db)
+
+ syncStats := memsto.NewSyncStats()
+ alertStats := astats.NewSyncStats()
+
+ targetCache := memsto.NewTargetCache(ctx, syncStats)
+ busiGroupCache := memsto.NewBusiGroupCache(ctx, syncStats)
+ alertMuteCache := memsto.NewAlertMuteCache(ctx, syncStats)
+
+ alertRuleCache := memsto.NewAlertRuleCache(ctx, syncStats)
+
+ promClients := prom.NewPromClient(ctx, config.Alert.Heartbeat)
+
+ externalProcessors := process.NewExternalProcessors()
+
+ Start(config.Alert, config.Pushgw, syncStats, alertStats, externalProcessors, targetCache, busiGroupCache, alertMuteCache, alertRuleCache, ctx, promClients)
+
+ r := httpx.GinEngine(config.Global.RunMode, config.HTTP)
+ rt := router.New(config.HTTP, config.Alert, alertMuteCache, targetCache, busiGroupCache, alertStats, ctx, externalProcessors)
+ rt.Config(r)
+
+ httpClean := httpx.Init(config.HTTP, r)
+
+ return func() {
+ logxClean()
+ httpClean()
+ }, nil
+}
+
+func Start(alertc aconf.Alert, pushgwc pconf.Pushgw, syncStats *memsto.Stats, alertStats *astats.Stats, externalProcessors *process.ExternalProcessorsType, targetCache *memsto.TargetCacheType, busiGroupCache *memsto.BusiGroupCacheType,
+ alertMuteCache *memsto.AlertMuteCacheType, alertRuleCache *memsto.AlertRuleCacheType, ctx *ctx.Context, promClients *prom.PromClientMap) {
+ userCache := memsto.NewUserCache(ctx, syncStats)
+ userGroupCache := memsto.NewUserGroupCache(ctx, syncStats)
+ alertSubscribeCache := memsto.NewAlertSubscribeCache(ctx, syncStats)
+ recordingRuleCache := memsto.NewRecordingRuleCache(ctx, syncStats)
+ webhookCache := memsto.NewWebhookCache(ctx)
+ notifyScript := memsto.NewNotifyScript(ctx)
+
+ go models.InitNotifyConfig(ctx, alertc.Alerting.TemplatesDir)
+
+ naming := naming.NewNaming(ctx, alertc.Heartbeat)
+
+ writers := writer.NewWriters(pushgwc)
+ record.NewScheduler(alertc, recordingRuleCache, promClients, writers, alertStats)
+
+ eval.NewScheduler(alertc, externalProcessors, alertRuleCache, targetCache, busiGroupCache, alertMuteCache, promClients, naming, ctx, alertStats)
+
+ dp := dispatch.NewDispatch(alertRuleCache, userCache, userGroupCache, alertSubscribeCache, targetCache, webhookCache, notifyScript, alertc.Alerting, alertc.Ibex, ctx)
+ consumer := dispatch.NewConsumer(alertc.Alerting, ctx, dp)
+
+ go dp.ReloadTpls()
+ go consumer.LoopConsume()
+
+ go queue.ReportQueueSize(alertStats)
+ go sender.StartEmailSender(alertc.SMTP)
+}
diff --git a/src/server/stat/stat.go b/alert/astats/stats.go
similarity index 61%
rename from src/server/stat/stat.go
rename to alert/astats/stats.go
index ca870315c901446c54284a0fe1bb9ed693765c25..e7519fa57a9b09e29c637aecb239f1b721b6068c 100644
--- a/src/server/stat/stat.go
+++ b/alert/astats/stats.go
@@ -1,4 +1,4 @@
-package stat
+package astats
import (
"github.com/prometheus/client_golang/prometheus"
@@ -6,28 +6,21 @@ import (
const (
namespace = "n9e"
- subsystem = "server"
+ subsystem = "alert"
)
-var (
- // 各个周期性任务的执行耗时
- GaugeCronDuration = prometheus.NewGaugeVec(prometheus.GaugeOpts{
- Namespace: namespace,
- Subsystem: subsystem,
- Name: "cron_duration",
- Help: "Cron method use duration, unit: ms.",
- }, []string{"name"})
-
- // 从数据库同步数据的时候，同步的条数
- GaugeSyncNumber = prometheus.NewGaugeVec(prometheus.GaugeOpts{
- Namespace: namespace,
- Subsystem: subsystem,
- Name: "cron_sync_number",
- Help: "Cron sync number.",
- }, []string{"name"})
+type Stats struct {
+ CounterSampleTotal *prometheus.CounterVec
+ CounterAlertsTotal *prometheus.CounterVec
+ GaugeAlertQueueSize prometheus.Gauge
+ GaugeSampleQueueSize *prometheus.GaugeVec
+ RequestDuration *prometheus.HistogramVec
+ ForwardDuration *prometheus.HistogramVec
+}
+func NewSyncStats() *Stats {
// 从各个接收接口接收到的监控数据总量
- CounterSampleTotal = prometheus.NewCounterVec(prometheus.CounterOpts{
+ CounterSampleTotal := prometheus.NewCounterVec(prometheus.CounterOpts{
Namespace: namespace,
Subsystem: subsystem,
Name: "samples_received_total",
@@ -35,7 +28,7 @@ var (
}, []string{"cluster", "channel"})
// 产生的告警总量
- CounterAlertsTotal = prometheus.NewCounterVec(prometheus.CounterOpts{
+ CounterAlertsTotal := prometheus.NewCounterVec(prometheus.CounterOpts{
Namespace: namespace,
Subsystem: subsystem,
Name: "alerts_total",
@@ -43,7 +36,7 @@ var (
}, []string{"cluster"})
// 内存中的告警事件队列的长度
- GaugeAlertQueueSize = prometheus.NewGauge(prometheus.GaugeOpts{
+ GaugeAlertQueueSize := prometheus.NewGauge(prometheus.GaugeOpts{
Namespace: namespace,
Subsystem: subsystem,
Name: "alert_queue_size",
@@ -51,7 +44,7 @@ var (
})
// 数据转发队列，各个队列的长度
- GaugeSampleQueueSize = prometheus.NewGaugeVec(prometheus.GaugeOpts{
+ GaugeSampleQueueSize := prometheus.NewGaugeVec(prometheus.GaugeOpts{
Namespace: namespace,
Subsystem: subsystem,
Name: "sample_queue_size",
@@ -59,7 +52,7 @@ var (
}, []string{"cluster", "channel_number"})
// 一些重要的请求，比如接收数据的请求，应该统计一下延迟情况
- RequestDuration = prometheus.NewHistogramVec(
+ RequestDuration := prometheus.NewHistogramVec(
prometheus.HistogramOpts{
Namespace: namespace,
Subsystem: subsystem,
@@ -70,7 +63,7 @@ var (
)
// 发往后端TSDB，延迟如何
- ForwardDuration = prometheus.NewHistogramVec(
+ ForwardDuration := prometheus.NewHistogramVec(
prometheus.HistogramOpts{
Namespace: namespace,
Subsystem: subsystem,
@@ -79,13 +72,8 @@ var (
Help: "Forward samples to TSDB. latencies in seconds.",
}, []string{"cluster", "channel_number"},
)
-)
-func Init() {
- // Register the summary and the histogram with Prometheus's default registry.
prometheus.MustRegister(
- GaugeCronDuration,
- GaugeSyncNumber,
CounterSampleTotal,
CounterAlertsTotal,
GaugeAlertQueueSize,
@@ -93,4 +81,13 @@ func Init() {
RequestDuration,
ForwardDuration,
)
+
+ return &Stats{
+ CounterSampleTotal: CounterSampleTotal,
+ CounterAlertsTotal: CounterAlertsTotal,
+ GaugeAlertQueueSize: GaugeAlertQueueSize,
+ GaugeSampleQueueSize: GaugeSampleQueueSize,
+ RequestDuration: RequestDuration,
+ ForwardDuration: ForwardDuration,
+ }
}
diff --git a/src/server/common/conv/conv.go b/alert/common/conv.go
similarity index 65%
rename from src/server/common/conv/conv.go
rename to alert/common/conv.go
index 0e38d378b3a4fa27e34c033565f6a8ceb2cc0cc3..bf1c069764ed49854efcf849b99e86b1be95dde4 100644
--- a/src/server/common/conv/conv.go
+++ b/alert/common/conv.go
@@ -1,4 +1,4 @@
-package conv
+package common
import (
"fmt"
@@ -8,20 +8,36 @@ import (
"github.com/prometheus/common/model"
)
-type Vector struct {
+type AnomalyPoint struct {
Key string `json:"key"`
Labels model.Metric `json:"labels"`
Timestamp int64 `json:"timestamp"`
Value float64 `json:"value"`
+ Severity int `json:"severity"`
}
-func (v *Vector) ReadableValue() string {
+func NewAnomalyPoint(key string, labels map[string]string, ts int64, value float64, severity int) AnomalyPoint {
+ anomalyPointLabels := make(model.Metric)
+ for k, v := range labels {
+ anomalyPointLabels[model.LabelName(k)] = model.LabelValue(v)
+ }
+ anomalyPointLabels[model.MetricNameLabel] = model.LabelValue(key)
+ return AnomalyPoint{
+ Key: key,
+ Labels: anomalyPointLabels,
+ Timestamp: ts,
+ Value: value,
+ Severity: severity,
+ }
+}
+
+func (v *AnomalyPoint) ReadableValue() string {
ret := fmt.Sprintf("%.5f", v.Value)
ret = strings.TrimRight(ret, "0")
return strings.TrimRight(ret, ".")
}
-func ConvertVectors(value model.Value) (lst []Vector) {
+func ConvertAnomalyPoints(value model.Value) (lst []AnomalyPoint) {
if value == nil {
return
}
@@ -38,7 +54,7 @@ func ConvertVectors(value model.Value) (lst []Vector) {
continue
}
- lst = append(lst, Vector{
+ lst = append(lst, AnomalyPoint{
Key: item.Metric.String(),
Timestamp: item.Timestamp.Unix(),
Value: float64(item.Value),
@@ -62,7 +78,7 @@ func ConvertVectors(value model.Value) (lst []Vector) {
continue
}
- lst = append(lst, Vector{
+ lst = append(lst, AnomalyPoint{
Key: item.Metric.String(),
Labels: item.Metric,
Timestamp: last.Timestamp.Unix(),
@@ -79,7 +95,7 @@ func ConvertVectors(value model.Value) (lst []Vector) {
return
}
- lst = append(lst, Vector{
+ lst = append(lst, AnomalyPoint{
Key: "{}",
Timestamp: item.Timestamp.Unix(),
Value: float64(item.Value),
diff --git a/alert/common/key.go b/alert/common/key.go
new file mode 100644
index 0000000000000000000000000000000000000000..0458e95b8ae77468fa45502e9eb21680b7ffddf5
--- /dev/null
+++ b/alert/common/key.go
@@ -0,0 +1,45 @@
+package common
+
+import (
+ "fmt"
+
+ "github.com/ccfos/nightingale/v6/models"
+)
+
+func RuleKey(datasourceId, id int64) string {
+ return fmt.Sprintf("alert-%d-%d", datasourceId, id)
+}
+
+func MatchTags(eventTagsMap map[string]string, itags []models.TagFilter) bool {
+ for _, filter := range itags {
+ value, has := eventTagsMap[filter.Key]
+ if !has {
+ return false
+ }
+ if !matchTag(value, filter) {
+ return false
+ }
+ }
+ return true
+}
+
+func matchTag(value string, filter models.TagFilter) bool {
+ switch filter.Func {
+ case "==":
+ return filter.Value == value
+ case "!=":
+ return filter.Value != value
+ case "in":
+ _, has := filter.Vset[value]
+ return has
+ case "not in":
+ _, has := filter.Vset[value]
+ return !has
+ case "=~":
+ return filter.Regexp.MatchString(value)
+ case "!~":
+ return !filter.Regexp.MatchString(value)
+ }
+ // unexpect func
+ return false
+}
diff --git a/src/server/engine/consume.go b/alert/dispatch/consume.go
similarity index 60%
rename from src/server/engine/consume.go
rename to alert/dispatch/consume.go
index 480d4bbd41d2619f511e89f0624595dc7a77d187..0b4e2ab7c25d417ed613c2d1391ab762b2d6ef95 100644
--- a/src/server/engine/consume.go
+++ b/alert/dispatch/consume.go
@@ -1,33 +1,48 @@
-package engine
+package dispatch
import (
- "context"
"fmt"
- "strconv"
"time"
+ "github.com/ccfos/nightingale/v6/alert/aconf"
+ "github.com/ccfos/nightingale/v6/alert/queue"
+ "github.com/ccfos/nightingale/v6/models"
+ "github.com/ccfos/nightingale/v6/pkg/ctx"
+
"github.com/toolkits/pkg/concurrent/semaphore"
"github.com/toolkits/pkg/logger"
-
- "github.com/didi/nightingale/v5/src/models"
- "github.com/didi/nightingale/v5/src/server/config"
- "github.com/didi/nightingale/v5/src/server/memsto"
)
-func loopConsume(ctx context.Context) {
- sema := semaphore.NewSemaphore(config.C.Alerting.NotifyConcurrency)
+type Consumer struct {
+ alerting aconf.Alerting
+ ctx *ctx.Context
+
+ dispatch *Dispatch
+}
+
+// 创建一个 Consumer 实例
+func NewConsumer(alerting aconf.Alerting, ctx *ctx.Context, dispatch *Dispatch) *Consumer {
+ return &Consumer{
+ alerting: alerting,
+ ctx: ctx,
+ dispatch: dispatch,
+ }
+}
+
+func (e *Consumer) LoopConsume() {
+ sema := semaphore.NewSemaphore(e.alerting.NotifyConcurrency)
duration := time.Duration(100) * time.Millisecond
for {
- events := EventQueue.PopBackBy(100)
+ events := queue.EventQueue.PopBackBy(100)
if len(events) == 0 {
time.Sleep(duration)
continue
}
- consume(events, sema)
+ e.consume(events, sema)
}
}
-func consume(events []interface{}, sema *semaphore.Semaphore) {
+func (e *Consumer) consume(events []interface{}, sema *semaphore.Semaphore) {
for i := range events {
if events[i] == nil {
continue
@@ -37,12 +52,12 @@ func consume(events []interface{}, sema *semaphore.Semaphore) {
sema.Acquire()
go func(event *models.AlertCurEvent) {
defer sema.Release()
- consumeOne(event)
+ e.consumeOne(event)
}(event)
}
}
-func consumeOne(event *models.AlertCurEvent) {
+func (e *Consumer) consumeOne(event *models.AlertCurEvent) {
LogEvent(event, "consume")
if err := event.ParseRule("rule_name"); err != nil {
@@ -53,26 +68,32 @@ func consumeOne(event *models.AlertCurEvent) {
event.RuleNote = fmt.Sprintf("failed to parse rule note: %v", err)
}
- persist(event)
+ if err := event.ParseRule("annotations"); err != nil {
+ event.Annotations = fmt.Sprintf("failed to parse rule note: %v", err)
+ }
+
+ logger.Info("event_persist: event.Annotations", event.Annotations)
+
+ e.persist(event)
if event.IsRecovered && event.NotifyRecovered == 0 {
return
}
- HandleEventNotify(event, false)
+ e.dispatch.HandleEventNotify(event, false)
}
-func persist(event *models.AlertCurEvent) {
- has, err := models.AlertCurEventExists("hash=?", event.Hash)
+func (e *Consumer) persist(event *models.AlertCurEvent) {
+ has, err := models.AlertCurEventExists(e.ctx, "hash=?", event.Hash)
if err != nil {
logger.Errorf("event_persist_check_exists_fail: %v rule_id=%d hash=%s", err, event.RuleId, event.Hash)
return
}
- his := event.ToHis()
+ his := event.ToHis(e.ctx)
// 不管是告警还是恢复，全量告警里都要记录
- if err := his.Add(); err != nil {
+ if err := his.Add(e.ctx); err != nil {
logger.Errorf(
"event_persist_his_fail: %v rule_id=%d cluster:%s hash=%s tags=%v timestamp=%d value=%s",
err,
@@ -87,7 +108,7 @@ func persist(event *models.AlertCurEvent) {
if has {
// 活跃告警表中有记录，删之
- err = models.AlertCurEventDelByHash(event.Hash)
+ err = models.AlertCurEventDelByHash(e.ctx, event.Hash)
if err != nil {
logger.Errorf("event_del_cur_fail: %v hash=%s", err, event.Hash)
return
@@ -98,7 +119,7 @@ func persist(event *models.AlertCurEvent) {
// use his id as cur id
event.Id = his.Id
if event.Id > 0 {
- if err := event.Add(); err != nil {
+ if err := event.Add(e.ctx); err != nil {
logger.Errorf(
"event_persist_cur_fail: %v rule_id=%d cluster:%s hash=%s tags=%v timestamp=%d value=%s",
err,
@@ -124,7 +145,7 @@ func persist(event *models.AlertCurEvent) {
// use his id as cur id
event.Id = his.Id
if event.Id > 0 {
- if err := event.Add(); err != nil {
+ if err := event.Add(e.ctx); err != nil {
logger.Errorf(
"event_persist_cur_fail: %v rule_id=%d cluster:%s hash=%s tags=%v timestamp=%d value=%s",
err,
@@ -138,35 +159,3 @@ func persist(event *models.AlertCurEvent) {
}
}
}
-
-// for alerting
-func fillUsers(e *models.AlertCurEvent) {
- gids := make([]int64, 0, len(e.NotifyGroupsJSON))
- for i := 0; i < len(e.NotifyGroupsJSON); i++ {
- gid, err := strconv.ParseInt(e.NotifyGroupsJSON[i], 10, 64)
- if err != nil {
- continue
- }
- gids = append(gids, gid)
- }
-
- e.NotifyGroupsObj = memsto.UserGroupCache.GetByUserGroupIds(gids)
-
- uids := make(map[int64]struct{})
- for i := 0; i < len(e.NotifyGroupsObj); i++ {
- ug := e.NotifyGroupsObj[i]
- for j := 0; j < len(ug.UserIds); j++ {
- uids[ug.UserIds[j]] = struct{}{}
- }
- }
-
- e.NotifyUsersObj = memsto.UserCache.GetByUserIds(mapKeys(uids))
-}
-
-func mapKeys(m map[int64]struct{}) []int64 {
- lst := make([]int64, 0, len(m))
- for k := range m {
- lst = append(lst, k)
- }
- return lst
-}
diff --git a/alert/dispatch/dispatch.go b/alert/dispatch/dispatch.go
new file mode 100644
index 0000000000000000000000000000000000000000..cde14aaabec72eb7c81877f55cb72486c845891a
--- /dev/null
+++ b/alert/dispatch/dispatch.go
@@ -0,0 +1,262 @@
+package dispatch
+
+import (
+ "bytes"
+ "encoding/json"
+ "html/template"
+ "strconv"
+ "sync"
+ "time"
+
+ "github.com/ccfos/nightingale/v6/alert/aconf"
+ "github.com/ccfos/nightingale/v6/alert/common"
+ "github.com/ccfos/nightingale/v6/alert/sender"
+ "github.com/ccfos/nightingale/v6/memsto"
+ "github.com/ccfos/nightingale/v6/models"
+ "github.com/ccfos/nightingale/v6/pkg/ctx"
+
+ "github.com/toolkits/pkg/logger"
+)
+
+type Dispatch struct {
+ alertRuleCache *memsto.AlertRuleCacheType
+ userCache *memsto.UserCacheType
+ userGroupCache *memsto.UserGroupCacheType
+ alertSubscribeCache *memsto.AlertSubscribeCacheType
+ targetCache *memsto.TargetCacheType
+ webhookCache *memsto.WebhookCacheType
+ notifyScriptCache *memsto.NotifyScriptCacheType
+
+ alerting aconf.Alerting
+ ibex aconf.Ibex
+
+ senders map[string]sender.Sender
+ tpls map[string]*template.Template
+
+ ctx *ctx.Context
+
+ RwLock sync.RWMutex
+}
+
+// 创建一个 Notify 实例
+func NewDispatch(alertRuleCache *memsto.AlertRuleCacheType, userCache *memsto.UserCacheType, userGroupCache *memsto.UserGroupCacheType,
+ alertSubscribeCache *memsto.AlertSubscribeCacheType, targetCache *memsto.TargetCacheType, webhookCache *memsto.WebhookCacheType, notifyScriptCache *memsto.NotifyScriptCacheType,
+ alerting aconf.Alerting, ibex aconf.Ibex, ctx *ctx.Context) *Dispatch {
+ notify := &Dispatch{
+ alertRuleCache: alertRuleCache,
+ userCache: userCache,
+ userGroupCache: userGroupCache,
+ alertSubscribeCache: alertSubscribeCache,
+ targetCache: targetCache,
+ webhookCache: webhookCache,
+ notifyScriptCache: notifyScriptCache,
+
+ alerting: alerting,
+ ibex: ibex,
+
+ senders: make(map[string]sender.Sender),
+ tpls: make(map[string]*template.Template),
+
+ ctx: ctx,
+ }
+ return notify
+}
+
+func (e *Dispatch) ReloadTpls() error {
+ err := e.relaodTpls()
+ if err != nil {
+ logger.Error("failed to reload tpls: %v", err)
+ }
+
+ duration := time.Duration(9000) * time.Millisecond
+ for {
+ time.Sleep(duration)
+ if err := e.relaodTpls(); err != nil {
+ logger.Warning("failed to reload tpls:", err)
+ }
+ }
+}
+
+func (e *Dispatch) relaodTpls() error {
+ tmpTpls, err := models.ListTpls(e.ctx)
+ if err != nil {
+ return err
+ }
+
+ senders := map[string]sender.Sender{
+ models.Email: sender.NewSender(models.Email, tmpTpls),
+ models.Dingtalk: sender.NewSender(models.Dingtalk, tmpTpls),
+ models.Wecom: sender.NewSender(models.Wecom, tmpTpls),
+ models.Feishu: sender.NewSender(models.Feishu, tmpTpls),
+ models.Mm: sender.NewSender(models.Mm, tmpTpls),
+ models.Telegram: sender.NewSender(models.Telegram, tmpTpls),
+ }
+
+ e.RwLock.Lock()
+ e.tpls = tmpTpls
+ e.senders = senders
+ e.RwLock.Unlock()
+ return nil
+}
+
+// HandleEventNotify 处理event事件的主逻辑
+// event: 告警/恢复事件
+// isSubscribe: 告警事件是否由subscribe的配置产生
+func (e *Dispatch) HandleEventNotify(event *models.AlertCurEvent, isSubscribe bool) {
+ rule := e.alertRuleCache.Get(event.RuleId)
+ if rule == nil {
+ return
+ }
+ fillUsers(event, e.userCache, e.userGroupCache)
+
+ var (
+ // 处理事件到 notifyTarget 关系,处理的notifyTarget用OrMerge进行合并
+ handlers []NotifyTargetDispatch
+
+ // 额外去掉一些订阅,处理的notifyTarget用AndMerge进行合并, 如设置 channel=false,合并后不通过这个channel发送
+ // 如果实现了相关 Dispatch,可以添加到interceptors中
+ interceptorHandlers []NotifyTargetDispatch
+ )
+ if isSubscribe {
+ handlers = []NotifyTargetDispatch{NotifyGroupDispatch, EventCallbacksDispatch}
+ } else {
+ handlers = []NotifyTargetDispatch{NotifyGroupDispatch, GlobalWebhookDispatch, EventCallbacksDispatch}
+ }
+
+ notifyTarget := NewNotifyTarget()
+ // 处理订阅关系使用OrMerge
+ for _, handler := range handlers {
+ notifyTarget.OrMerge(handler(rule, event, notifyTarget, e))
+ }
+
+ // 处理移除订阅关系的逻辑,比如员工离职，临时静默某个通道的策略等
+ for _, handler := range interceptorHandlers {
+ notifyTarget.AndMerge(handler(rule, event, notifyTarget, e))
+ }
+
+ // 处理事件发送,这里用一个goroutine处理一个event的所有发送事件
+ go e.Send(rule, event, notifyTarget, isSubscribe)
+
+ // 如果是不是订阅规则出现的event, 则需要处理订阅规则的event
+ if !isSubscribe {
+ e.handleSubs(event)
+ }
+}
+
+func (e *Dispatch) handleSubs(event *models.AlertCurEvent) {
+ // handle alert subscribes
+ subscribes := make([]*models.AlertSubscribe, 0)
+ // rule specific subscribes
+ if subs, has := e.alertSubscribeCache.Get(event.RuleId); has {
+ subscribes = append(subscribes, subs...)
+ }
+ // global subscribes
+ if subs, has := e.alertSubscribeCache.Get(0); has {
+ subscribes = append(subscribes, subs...)
+ }
+
+ for _, sub := range subscribes {
+ e.handleSub(sub, *event)
+ }
+}
+
+// handleSub 处理订阅规则的event,注意这里event要使用值传递,因为后面会修改event的状态
+func (e *Dispatch) handleSub(sub *models.AlertSubscribe, event models.AlertCurEvent) {
+ if sub.IsDisabled() || !sub.MatchCluster(event.DatasourceId) {
+ return
+ }
+ if !common.MatchTags(event.TagsMap, sub.ITags) {
+ return
+ }
+ if sub.ForDuration > (event.TriggerTime - event.FirstTriggerTime) {
+ return
+ }
+ sub.ModifyEvent(&event)
+ LogEvent(&event, "subscribe")
+ e.HandleEventNotify(&event, true)
+}
+
+func (e *Dispatch) Send(rule *models.AlertRule, event *models.AlertCurEvent, notifyTarget *NotifyTarget, isSubscribe bool) {
+ for channel, uids := range notifyTarget.ToChannelUserMap() {
+ ctx := sender.BuildMessageContext(rule, event, uids, e.userCache)
+ e.RwLock.RLock()
+ s := e.senders[channel]
+ e.RwLock.RUnlock()
+ if s == nil {
+ logger.Warningf("no sender for channel: %s", channel)
+ continue
+ }
+ s.Send(ctx)
+ }
+
+ // handle event callbacks
+ sender.SendCallbacks(e.ctx, notifyTarget.ToCallbackList(), event, e.targetCache, e.ibex)
+
+ // handle global webhooks
+ sender.SendWebhooks(notifyTarget.ToWebhookList(), event)
+
+ // handle plugin call
+ go sender.MayPluginNotify(e.genNoticeBytes(event), e.notifyScriptCache)
+}
+
+type Notice struct {
+ Event *models.AlertCurEvent `json:"event"`
+ Tpls map[string]string `json:"tpls"`
+}
+
+func (e *Dispatch) genNoticeBytes(event *models.AlertCurEvent) []byte {
+ // build notice body with templates
+ ntpls := make(map[string]string)
+
+ e.RwLock.RLock()
+ defer e.RwLock.RUnlock()
+ for filename, tpl := range e.tpls {
+ var body bytes.Buffer
+ if err := tpl.Execute(&body, event); err != nil {
+ ntpls[filename] = err.Error()
+ } else {
+ ntpls[filename] = body.String()
+ }
+ }
+
+ notice := Notice{Event: event, Tpls: ntpls}
+ stdinBytes, err := json.Marshal(notice)
+ if err != nil {
+ logger.Errorf("event_notify: failed to marshal notice: %v", err)
+ return nil
+ }
+
+ return stdinBytes
+}
+
+// for alerting
+func fillUsers(ce *models.AlertCurEvent, uc *memsto.UserCacheType, ugc *memsto.UserGroupCacheType) {
+ gids := make([]int64, 0, len(ce.NotifyGroupsJSON))
+ for i := 0; i < len(ce.NotifyGroupsJSON); i++ {
+ gid, err := strconv.ParseInt(ce.NotifyGroupsJSON[i], 10, 64)
+ if err != nil {
+ continue
+ }
+ gids = append(gids, gid)
+ }
+
+ ce.NotifyGroupsObj = ugc.GetByUserGroupIds(gids)
+
+ uids := make(map[int64]struct{})
+ for i := 0; i < len(ce.NotifyGroupsObj); i++ {
+ ug := ce.NotifyGroupsObj[i]
+ for j := 0; j < len(ug.UserIds); j++ {
+ uids[ug.UserIds[j]] = struct{}{}
+ }
+ }
+
+ ce.NotifyUsersObj = uc.GetByUserIds(mapKeys(uids))
+}
+
+func mapKeys(m map[int64]struct{}) []int64 {
+ lst := make([]int64, 0, len(m))
+ for k := range m {
+ lst = append(lst, k)
+ }
+ return lst
+}
diff --git a/src/server/engine/logger.go b/alert/dispatch/log.go
similarity index 89%
rename from src/server/engine/logger.go
rename to alert/dispatch/log.go
index 190b868e024690910c1d91aa7e29d1da47a9cd8b..f51f7fb12b1d71372dca0d02b5fe9062edf6f990 100644
--- a/src/server/engine/logger.go
+++ b/alert/dispatch/log.go
@@ -1,9 +1,9 @@
-package engine
+package dispatch
import (
- "github.com/toolkits/pkg/logger"
+ "github.com/ccfos/nightingale/v6/models"
- "github.com/didi/nightingale/v5/src/models"
+ "github.com/toolkits/pkg/logger"
)
func LogEvent(event *models.AlertCurEvent, location string, err ...error) {
diff --git a/alert/dispatch/notify_channel.go b/alert/dispatch/notify_channel.go
new file mode 100644
index 0000000000000000000000000000000000000000..cb2fd8c00f6432806972b3347ba6d7d9ecc71a27
--- /dev/null
+++ b/alert/dispatch/notify_channel.go
@@ -0,0 +1,33 @@
+package dispatch
+
+// NotifyChannels channelKey -> bool
+type NotifyChannels map[string]bool
+
+func NewNotifyChannels(channels []string) NotifyChannels {
+ nc := make(NotifyChannels)
+ for _, ch := range channels {
+ nc[ch] = true
+ }
+ return nc
+}
+
+func (nc NotifyChannels) OrMerge(other NotifyChannels) {
+ nc.merge(other, func(a, b bool) bool { return a || b })
+}
+
+func (nc NotifyChannels) AndMerge(other NotifyChannels) {
+ nc.merge(other, func(a, b bool) bool { return a && b })
+}
+
+func (nc NotifyChannels) merge(other NotifyChannels, f func(bool, bool) bool) {
+ if other == nil {
+ return
+ }
+ for k, v := range other {
+ if curV, has := nc[k]; has {
+ nc[k] = f(curV, v)
+ } else {
+ nc[k] = v
+ }
+ }
+}
diff --git a/alert/dispatch/notify_target.go b/alert/dispatch/notify_target.go
new file mode 100644
index 0000000000000000000000000000000000000000..453ecab94564a9296eacbb5045ad4afbe7af1e64
--- /dev/null
+++ b/alert/dispatch/notify_target.go
@@ -0,0 +1,134 @@
+package dispatch
+
+import (
+ "strconv"
+
+ "github.com/ccfos/nightingale/v6/models"
+)
+
+// NotifyTarget 维护所有需要发送的目标 用户-通道/回调/钩子信息,用map维护的数据结构具有去重功能
+type NotifyTarget struct {
+ userMap map[int64]NotifyChannels
+ webhooks map[string]*models.Webhook
+ callbacks map[string]struct{}
+}
+
+func NewNotifyTarget() *NotifyTarget {
+ return &NotifyTarget{
+ userMap: make(map[int64]NotifyChannels),
+ webhooks: make(map[string]*models.Webhook),
+ callbacks: make(map[string]struct{}),
+ }
+}
+
+// OrMerge 将 channelMap 按照 or 的方式合并,方便实现多种组合的策略,比如根据某个 tag 进行路由等
+func (s *NotifyTarget) OrMerge(other *NotifyTarget) {
+ s.merge(other, NotifyChannels.OrMerge)
+}
+
+// AndMerge 将 channelMap 中的 bool 值按照 and 的逻辑进行合并,可以单独将人/通道维度的通知移除
+// 常用的场景有:
+// 1. 人员离职了不需要发送告警了
+// 2. 某个告警通道进行维护,暂时不需要发送告警了
+// 3. 业务值班的重定向逻辑，将高等级的告警额外发送给应急人员等
+// 可以结合业务需求自己实现router
+func (s *NotifyTarget) AndMerge(other *NotifyTarget) {
+ s.merge(other, NotifyChannels.AndMerge)
+}
+
+func (s *NotifyTarget) merge(other *NotifyTarget, f func(NotifyChannels, NotifyChannels)) {
+ if other == nil {
+ return
+ }
+ for k, v := range other.userMap {
+ if curV, has := s.userMap[k]; has {
+ f(curV, v)
+ } else {
+ s.userMap[k] = v
+ }
+ }
+ for k, v := range other.webhooks {
+ s.webhooks[k] = v
+ }
+ for k, v := range other.callbacks {
+ s.callbacks[k] = v
+ }
+}
+
+// ToChannelUserMap userMap(map[uid][channel]bool) 转换为 map[channel][]uid 的结构
+func (s *NotifyTarget) ToChannelUserMap() map[string][]int64 {
+ m := make(map[string][]int64)
+ for uid, nc := range s.userMap {
+ for ch, send := range nc {
+ if send {
+ m[ch] = append(m[ch], uid)
+ }
+ }
+ }
+ return m
+}
+
+func (s *NotifyTarget) ToCallbackList() []string {
+ callbacks := make([]string, 0, len(s.callbacks))
+ for cb := range s.callbacks {
+ callbacks = append(callbacks, cb)
+ }
+ return callbacks
+}
+
+func (s *NotifyTarget) ToWebhookList() []*models.Webhook {
+ webhooks := make([]*models.Webhook, 0, len(s.webhooks))
+ for _, wh := range s.webhooks {
+ webhooks = append(webhooks, wh)
+ }
+ return webhooks
+}
+
+// Dispatch 抽象由告警事件到信息接收者的路由策略
+// rule: 告警规则
+// event: 告警事件
+// prev: 前一次路由结果, Dispatch 的实现可以直接修改 prev, 也可以返回一个新的 NotifyTarget 用于 AndMerge/OrMerge
+type NotifyTargetDispatch func(rule *models.AlertRule, event *models.AlertCurEvent, prev *NotifyTarget, dispatch *Dispatch) *NotifyTarget
+
+// GroupDispatch 处理告警规则的组订阅关系
+func NotifyGroupDispatch(rule *models.AlertRule, event *models.AlertCurEvent, prev *NotifyTarget, dispatch *Dispatch) *NotifyTarget {
+ groupIds := make([]int64, 0, len(event.NotifyGroupsJSON))
+ for _, groupId := range event.NotifyGroupsJSON {
+ gid, err := strconv.ParseInt(groupId, 10, 64)
+ if err != nil {
+ continue
+ }
+ groupIds = append(groupIds, gid)
+ }
+
+ groups := dispatch.userGroupCache.GetByUserGroupIds(groupIds)
+ NotifyTarget := NewNotifyTarget()
+ for _, group := range groups {
+ for _, userId := range group.UserIds {
+ NotifyTarget.userMap[userId] = NewNotifyChannels(event.NotifyChannelsJSON)
+ }
+ }
+ return NotifyTarget
+}
+
+func GlobalWebhookDispatch(rule *models.AlertRule, event *models.AlertCurEvent, prev *NotifyTarget, dispatch *Dispatch) *NotifyTarget {
+ webhooks := dispatch.webhookCache.GetWebhooks()
+ NotifyTarget := NewNotifyTarget()
+ for _, webhook := range webhooks {
+ if !webhook.Enable {
+ continue
+ }
+ NotifyTarget.webhooks[webhook.Url] = webhook
+ }
+ return NotifyTarget
+}
+
+func EventCallbacksDispatch(rule *models.AlertRule, event *models.AlertCurEvent, prev *NotifyTarget, dispatch *Dispatch) *NotifyTarget {
+ for _, c := range event.CallbacksJSON {
+ if c == "" {
+ continue
+ }
+ prev.callbacks[c] = struct{}{}
+ }
+ return nil
+}
diff --git a/alert/eval/alert_rule.go b/alert/eval/alert_rule.go
new file mode 100644
index 0000000000000000000000000000000000000000..20654d9e56bdec9e7ec7715441f04f3459ecec44
--- /dev/null
+++ b/alert/eval/alert_rule.go
@@ -0,0 +1,149 @@
+package eval
+
+import (
+ "context"
+ "fmt"
+ "time"
+
+ "github.com/ccfos/nightingale/v6/alert/aconf"
+ "github.com/ccfos/nightingale/v6/alert/astats"
+ "github.com/ccfos/nightingale/v6/alert/naming"
+ "github.com/ccfos/nightingale/v6/alert/process"
+ "github.com/ccfos/nightingale/v6/memsto"
+ "github.com/ccfos/nightingale/v6/pkg/ctx"
+ "github.com/ccfos/nightingale/v6/prom"
+)
+
+type Scheduler struct {
+ // key: hash
+ alertRules map[string]*AlertRuleWorker
+
+ ExternalProcessors *process.ExternalProcessorsType
+
+ aconf aconf.Alert
+
+ alertRuleCache *memsto.AlertRuleCacheType
+ targetCache *memsto.TargetCacheType
+ busiGroupCache *memsto.BusiGroupCacheType
+ alertMuteCache *memsto.AlertMuteCacheType
+
+ promClients *prom.PromClientMap
+
+ naming *naming.Naming
+
+ ctx *ctx.Context
+ stats *astats.Stats
+}
+
+func NewScheduler(aconf aconf.Alert, externalProcessors *process.ExternalProcessorsType, arc *memsto.AlertRuleCacheType, targetCache *memsto.TargetCacheType,
+ busiGroupCache *memsto.BusiGroupCacheType, alertMuteCache *memsto.AlertMuteCacheType, promClients *prom.PromClientMap, naming *naming.Naming,
+ ctx *ctx.Context, stats *astats.Stats) *Scheduler {
+ scheduler := &Scheduler{
+ aconf: aconf,
+ alertRules: make(map[string]*AlertRuleWorker),
+ // recordRules: make(map[string]RuleContext),
+ // externalAlertRules: make(map[string]*eval.AlertRuleWorker),
+
+ ExternalProcessors: externalProcessors,
+
+ alertRuleCache: arc,
+ targetCache: targetCache,
+ busiGroupCache: busiGroupCache,
+ alertMuteCache: alertMuteCache,
+
+ promClients: promClients,
+ naming: naming,
+
+ ctx: ctx,
+ stats: stats,
+ }
+
+ go scheduler.LoopSyncRules(context.Background())
+ return scheduler
+}
+
+func (s *Scheduler) LoopSyncRules(ctx context.Context) {
+ time.Sleep(time.Duration(s.aconf.EngineDelay) * time.Second)
+ duration := 9000 * time.Millisecond
+ for {
+ select {
+ case <-ctx.Done():
+ return
+ case <-time.After(duration):
+ s.syncAlertRules()
+ }
+ }
+}
+
+func (s *Scheduler) syncAlertRules() {
+ ids := s.alertRuleCache.GetRuleIds()
+ alertRuleWorkers := make(map[string]*AlertRuleWorker)
+ externalRuleWorkers := make(map[string]*process.Processor)
+ for _, id := range ids {
+ rule := s.alertRuleCache.Get(id)
+ if rule == nil {
+ continue
+ }
+ if rule.IsPrometheusRule() {
+ datasourceIds := s.promClients.Hit(rule.DatasourceIdsJson)
+ for _, dsId := range datasourceIds {
+ if !naming.DatasourceHashRing.IsHit(dsId, fmt.Sprintf("%d", rule.Id), s.aconf.Heartbeat.Endpoint) {
+ continue
+ }
+
+ processor := process.NewProcessor(rule, dsId, s.alertRuleCache, s.targetCache, s.busiGroupCache, s.alertMuteCache, s.promClients, s.ctx, s.stats)
+
+ alertRule := NewAlertRuleWorker(rule, dsId, processor, s.promClients, s.ctx)
+ alertRuleWorkers[alertRule.Hash()] = alertRule
+ }
+ } else if rule.IsHostRule() && s.naming.IamLeader() {
+ // all host rule will be processed by leader
+ processor := process.NewProcessor(rule, 0, s.alertRuleCache, s.targetCache, s.busiGroupCache, s.alertMuteCache, s.promClients, s.ctx, s.stats)
+ alertRule := NewAlertRuleWorker(rule, 0, processor, s.promClients, s.ctx)
+ alertRuleWorkers[alertRule.Hash()] = alertRule
+ } else {
+ // 如果 rule 不是通过 prometheus engine 来告警的，则创建为 externalRule
+ // if rule is not processed by prometheus engine, create it as externalRule
+ for _, dsId := range rule.DatasourceIdsJson {
+ processor := process.NewProcessor(rule, dsId, s.alertRuleCache, s.targetCache, s.busiGroupCache, s.alertMuteCache, s.promClients, s.ctx, s.stats)
+ externalRuleWorkers[processor.Key()] = processor
+ }
+ }
+ }
+
+ for hash, rule := range alertRuleWorkers {
+ if _, has := s.alertRules[hash]; !has {
+ rule.Prepare()
+ rule.Start()
+ s.alertRules[hash] = rule
+ }
+ }
+
+ for hash, rule := range s.alertRules {
+ if _, has := alertRuleWorkers[hash]; !has {
+ rule.Stop()
+ delete(s.alertRules, hash)
+ }
+ }
+
+ s.ExternalProcessors.ExternalLock.Lock()
+ for key, processor := range externalRuleWorkers {
+ if curProcessor, has := s.ExternalProcessors.Processors[key]; has {
+ // rule存在,且hash一致,认为没有变更,这里可以根据需求单独实现一个关联数据更多的hash函数
+ if processor.Hash() == curProcessor.Hash() {
+ continue
+ }
+ }
+
+ // 现有规则中没有rule以及有rule但hash不一致的场景，需要触发rule的update
+ processor.RecoverAlertCurEventFromDb()
+ s.ExternalProcessors.Processors[key] = processor
+ }
+
+ for key := range s.ExternalProcessors.Processors {
+ if _, has := externalRuleWorkers[key]; !has {
+ delete(s.ExternalProcessors.Processors, key)
+ }
+ }
+ s.ExternalProcessors.ExternalLock.Unlock()
+}
diff --git a/alert/eval/eval.go b/alert/eval/eval.go
new file mode 100644
index 0000000000000000000000000000000000000000..7f9b701196540a2b5d6f7830179d06820db12a66
--- /dev/null
+++ b/alert/eval/eval.go
@@ -0,0 +1,227 @@
+package eval
+
+import (
+ "context"
+ "encoding/json"
+ "fmt"
+ "strings"
+ "time"
+
+ "github.com/ccfos/nightingale/v6/alert/common"
+ "github.com/ccfos/nightingale/v6/alert/process"
+ "github.com/ccfos/nightingale/v6/models"
+ "github.com/ccfos/nightingale/v6/pkg/ctx"
+ promsdk "github.com/ccfos/nightingale/v6/pkg/prom"
+ "github.com/ccfos/nightingale/v6/prom"
+
+ "github.com/toolkits/pkg/logger"
+ "github.com/toolkits/pkg/str"
+)
+
+type AlertRuleWorker struct {
+ datasourceId int64
+ quit chan struct{}
+ inhibit bool
+ severity int
+
+ rule *models.AlertRule
+
+ processor *process.Processor
+
+ promClients *prom.PromClientMap
+ ctx *ctx.Context
+}
+
+func NewAlertRuleWorker(rule *models.AlertRule, datasourceId int64, processor *process.Processor, promClients *prom.PromClientMap, ctx *ctx.Context) *AlertRuleWorker {
+ arw := &AlertRuleWorker{
+ datasourceId: datasourceId,
+ quit: make(chan struct{}),
+ rule: rule,
+ processor: processor,
+
+ promClients: promClients,
+ ctx: ctx,
+ }
+
+ return arw
+}
+
+func (arw *AlertRuleWorker) Key() string {
+ return common.RuleKey(arw.datasourceId, arw.rule.Id)
+}
+
+func (arw *AlertRuleWorker) Hash() string {
+ return str.MD5(fmt.Sprintf("%d_%d_%s_%d",
+ arw.rule.Id,
+ arw.rule.PromEvalInterval,
+ arw.rule.RuleConfig,
+ arw.datasourceId,
+ ))
+}
+
+func (arw *AlertRuleWorker) Prepare() {
+ arw.processor.RecoverAlertCurEventFromDb()
+}
+
+func (arw *AlertRuleWorker) Start() {
+ logger.Infof("eval:%s started", arw.Key())
+ interval := arw.rule.PromEvalInterval
+ if interval <= 0 {
+ interval = 10
+ }
+ go func() {
+ for {
+ select {
+ case <-arw.quit:
+ return
+ default:
+ arw.Eval()
+ time.Sleep(time.Duration(interval) * time.Second)
+ }
+ }
+ }()
+}
+
+func (arw *AlertRuleWorker) Eval() {
+ cachedRule := arw.rule
+ if cachedRule == nil {
+ logger.Errorf("rule_eval:%s rule not found", arw.Key())
+ return
+ }
+
+ typ := cachedRule.GetRuleType()
+ var lst []common.AnomalyPoint
+ switch typ {
+ case models.PROMETHEUS:
+ lst = arw.GetPromAnomalyPoint(cachedRule.RuleConfig)
+ case models.HOST:
+ lst = arw.GetHostAnomalyPoint(cachedRule.RuleConfig)
+ default:
+ return
+ }
+
+ arw.processor.Handle(lst, "inner", arw.inhibit)
+}
+
+func (arw *AlertRuleWorker) Stop() {
+ logger.Infof("%s stopped", arw.Key())
+ close(arw.quit)
+}
+
+func (arw *AlertRuleWorker) GetPromAnomalyPoint(ruleConfig string) []common.AnomalyPoint {
+ var lst []common.AnomalyPoint
+ var severity int
+
+ var rule *models.PromRuleConfig
+ if err := json.Unmarshal([]byte(ruleConfig), &rule); err != nil {
+ logger.Errorf("rule_eval:%s rule_config:%s, error:%v", arw.Key(), ruleConfig, err)
+ return lst
+ }
+
+ if rule == nil {
+ logger.Errorf("rule_eval:%s rule_config:%s, error:rule is nil", arw.Key(), ruleConfig)
+ return lst
+ }
+
+ arw.inhibit = rule.Inhibit
+ for _, query := range rule.Queries {
+ if query.Severity < severity {
+ arw.severity = query.Severity
+ }
+
+ promql := strings.TrimSpace(query.PromQl)
+ if promql == "" {
+ logger.Errorf("rule_eval:%s promql is blank", arw.Key())
+ continue
+ }
+
+ if arw.promClients.IsNil(arw.datasourceId) {
+ logger.Errorf("rule_eval:%s error reader client is nil", arw.Key())
+ continue
+ }
+
+ readerClient := arw.promClients.GetCli(arw.datasourceId)
+
+ var warnings promsdk.Warnings
+ value, warnings, err := readerClient.Query(context.Background(), promql, time.Now())
+ if err != nil {
+ logger.Errorf("rule_eval:%s promql:%s, error:%v", arw.Key(), promql, err)
+ continue
+ }
+
+ if len(warnings) > 0 {
+ logger.Errorf("rule_eval:%s promql:%s, warnings:%v", arw.Key(), promql, warnings)
+ continue
+ }
+
+ logger.Debugf("rule_eval:%s query:%+v, value:%v", arw.Key(), query, value)
+ points := common.ConvertAnomalyPoints(value)
+ for i := 0; i < len(points); i++ {
+ points[i].Severity = query.Severity
+ }
+ lst = append(lst, points...)
+ }
+ return lst
+}
+
+func (arw *AlertRuleWorker) GetHostAnomalyPoint(ruleConfig string) []common.AnomalyPoint {
+ var lst []common.AnomalyPoint
+ var severity int
+
+ var rule *models.HostRuleConfig
+ if err := json.Unmarshal([]byte(ruleConfig), &rule); err != nil {
+ logger.Errorf("rule_eval:%s rule_config:%s, error:%v", arw.Key(), ruleConfig, err)
+ return lst
+ }
+
+ if rule == nil {
+ logger.Errorf("rule_eval:%s rule_config:%s, error:rule is nil", arw.Key(), ruleConfig)
+ return lst
+ }
+
+ arw.inhibit = rule.Inhibit
+ now := time.Now().Unix()
+ for _, trigger := range rule.Triggers {
+ if trigger.Severity < severity {
+ arw.severity = trigger.Severity
+ }
+
+ query := models.GetHostsQuery(rule.Queries)
+ switch trigger.Type {
+ case "target_miss", "offset":
+ t := now - int64(trigger.Duration)
+ if trigger.Type == "offset" {
+ t = int64(trigger.Duration)
+ }
+
+ hosts, err := models.TargetGetsByFilter(arw.ctx, query, trigger.Type, t, 0, 0)
+ if err != nil {
+ logger.Errorf("rule_eval:%s query:%v, error:%v", arw.Key(), query, err)
+ continue
+ }
+
+ for _, host := range hosts {
+ m := make(map[string]string)
+ m["ident"] = host.Ident
+ lst = append(lst, common.NewAnomalyPoint(trigger.Type, m, now, float64(t), trigger.Severity))
+ }
+ case "pct_target_miss":
+ AllCount, err := models.TargetCountByFilter(arw.ctx, query, "", 0)
+ if err != nil {
+ logger.Errorf("rule_eval:%s query:%v, error:%v", arw.Key(), query, err)
+ continue
+ }
+ missCount, err := models.TargetCountByFilter(arw.ctx, query, trigger.Type, now-int64(trigger.Duration))
+ if err != nil {
+ logger.Errorf("rule_eval:%s query:%v, error:%v", arw.Key(), query, err)
+ continue
+ }
+
+ pct := float64(missCount) / float64(AllCount) * 100
+ if pct >= float64(trigger.Percent) {
+ lst = append(lst, common.NewAnomalyPoint(trigger.Type, nil, now, pct, trigger.Severity))
+ }
+ }
+ }
+ return lst
+}
diff --git a/src/server/engine/mute_strategy.go b/alert/mute/mute.go
similarity index 59%
rename from src/server/engine/mute_strategy.go
rename to alert/mute/mute.go
index 29278b571245c1eabd5ef6c51d44b521ef13d912..4f7d6a969b128811e17a7d46a1fa65eac3fc1b66 100644
--- a/src/server/engine/mute_strategy.go
+++ b/alert/mute/mute.go
@@ -1,31 +1,34 @@
-package engine
+package mute
import (
"strconv"
"strings"
"time"
- "github.com/toolkits/pkg/logger"
+ "github.com/ccfos/nightingale/v6/alert/common"
+ "github.com/ccfos/nightingale/v6/memsto"
+ "github.com/ccfos/nightingale/v6/models"
- "github.com/didi/nightingale/v5/src/models"
- "github.com/didi/nightingale/v5/src/server/memsto"
+ "github.com/toolkits/pkg/logger"
)
-type MuteStrategyFunc func(rule *models.AlertRule, event *models.AlertCurEvent) bool
+func IsMuted(rule *models.AlertRule, event *models.AlertCurEvent, targetCache *memsto.TargetCacheType, alertMuteCache *memsto.AlertMuteCacheType) bool {
+ if TimeNonEffectiveMuteStrategy(rule, event) {
+ return true
+ }
-var AlertMuteStrategies = []MuteStrategyFunc{
- TimeNonEffectiveMuteStrategy,
- IdentNotExistsMuteStrategy,
- BgNotMatchMuteStrategy,
- EventMuteStrategy,
-}
+ if IdentNotExistsMuteStrategy(rule, event, targetCache) {
+ return true
+ }
-func IsMuted(rule *models.AlertRule, event *models.AlertCurEvent) bool {
- for _, strategyFunc := range AlertMuteStrategies {
- if strategyFunc(rule, event) {
- return true
- }
+ if BgNotMatchMuteStrategy(rule, event, targetCache) {
+ return true
}
+
+ if EventMuteStrategy(event, alertMuteCache) {
+ return true
+ }
+
return false
}
@@ -65,12 +68,12 @@ func TimeNonEffectiveMuteStrategy(rule *models.AlertRule, event *models.AlertCur
}
// IdentNotExistsMuteStrategy 根据ident是否存在过滤,如果ident不存在,则target_up的告警直接过滤掉
-func IdentNotExistsMuteStrategy(rule *models.AlertRule, event *models.AlertCurEvent) bool {
+func IdentNotExistsMuteStrategy(rule *models.AlertRule, event *models.AlertCurEvent, targetCache *memsto.TargetCacheType) bool {
ident, has := event.TagsMap["ident"]
if !has {
return false
}
- _, exists := memsto.TargetCache.Get(ident)
+ _, exists := targetCache.Get(ident)
// 如果是target_up的告警,且ident已经不存在了,直接过滤掉
// 这里的判断有点太粗暴了,但是目前没有更好的办法
if !exists && strings.Contains(rule.PromQl, "target_up") {
@@ -81,7 +84,7 @@ func IdentNotExistsMuteStrategy(rule *models.AlertRule, event *models.AlertCurEv
}
// BgNotMatchMuteStrategy 当规则开启只在bg内部告警时,对于非bg内部的机器过滤
-func BgNotMatchMuteStrategy(rule *models.AlertRule, event *models.AlertCurEvent) bool {
+func BgNotMatchMuteStrategy(rule *models.AlertRule, event *models.AlertCurEvent, targetCache *memsto.TargetCacheType) bool {
// 没有开启BG内部告警,直接不过滤
if rule.EnableInBG == 0 {
return false
@@ -92,7 +95,7 @@ func BgNotMatchMuteStrategy(rule *models.AlertRule, event *models.AlertCurEvent)
return false
}
- target, exists := memsto.TargetCache.Get(ident)
+ target, exists := targetCache.Get(ident)
// 对于包含ident的告警事件，check一下ident所属bg和rule所属bg是否相同
// 如果告警规则选择了只在本BG生效，那其他BG的机器就不能因此规则产生告警
if exists && target.GroupId != rule.GroupId {
@@ -102,8 +105,8 @@ func BgNotMatchMuteStrategy(rule *models.AlertRule, event *models.AlertCurEvent)
return false
}
-func EventMuteStrategy(rule *models.AlertRule, event *models.AlertCurEvent) bool {
- mutes, has := memsto.AlertMuteCache.Gets(event.GroupId)
+func EventMuteStrategy(event *models.AlertCurEvent, alertMuteCache *memsto.AlertMuteCacheType) bool {
+ mutes, has := alertMuteCache.Gets(event.GroupId)
if !has || len(mutes) == 0 {
return false
}
@@ -122,64 +125,54 @@ func matchMute(event *models.AlertCurEvent, mute *models.AlertMute, clock ...int
if mute.Disabled == 1 {
return false
}
-
ts := event.TriggerTime
if len(clock) > 0 {
ts = clock[0]
}
- // 如果不是全局的，判断 cluster
- if mute.Cluster != models.ClusterAll {
- // mute.Cluster 是一个字符串，可能是多个cluster的组合，比如"cluster1 cluster2"
- clusters := strings.Fields(mute.Cluster)
- cm := make(map[string]struct{}, len(clusters))
- for i := 0; i < len(clusters); i++ {
- cm[clusters[i]] = struct{}{}
+ // 如果不是全局的，判断 匹配的 datasource id
+ if !(len(mute.DatasourceIdsJson) != 0 && mute.DatasourceIdsJson[0] == 0) && event.DatasourceId != 0 {
+ idm := make(map[int64]struct{}, len(mute.DatasourceIdsJson))
+ for i := 0; i < len(mute.DatasourceIdsJson); i++ {
+ idm[mute.DatasourceIdsJson[i]] = struct{}{}
}
- // 判断event.Cluster是否包含在cm中
- if _, has := cm[event.Cluster]; !has {
+ // 判断 event.datasourceId 是否包含在 idm 中
+ if _, has := idm[event.DatasourceId]; !has {
return false
}
}
- if ts < mute.Btime || ts > mute.Etime {
- return false
- }
-
- return matchTags(event.TagsMap, mute.ITags)
-}
-
-func matchTag(value string, filter models.TagFilter) bool {
- switch filter.Func {
- case "==":
- return filter.Value == value
- case "!=":
- return filter.Value != value
- case "in":
- _, has := filter.Vset[value]
- return has
- case "not in":
- _, has := filter.Vset[value]
- return !has
- case "=~":
- return filter.Regexp.MatchString(value)
- case "!~":
- return !filter.Regexp.MatchString(value)
- }
- // unexpect func
- return false
-}
-
-func matchTags(eventTagsMap map[string]string, itags []models.TagFilter) bool {
- for _, filter := range itags {
- value, has := eventTagsMap[filter.Key]
- if !has {
+ var matchTime bool
+ if mute.MuteTimeType == models.TimeRange {
+ if ts < mute.Btime || ts > mute.Etime {
return false
}
- if !matchTag(value, filter) {
- return false
+ matchTime = true
+ } else if mute.MuteTimeType == models.Periodic {
+ tm := time.Unix(event.TriggerTime, 0)
+ triggerTime := tm.Format("15:04")
+ triggerWeek := strconv.Itoa(int(tm.Weekday()))
+
+ for i := 0; i < len(mute.PeriodicMutesJson); i++ {
+ if strings.Contains(mute.PeriodicMutesJson[i].EnableDaysOfWeek, triggerWeek) {
+ if mute.PeriodicMutesJson[i].EnableStime <= mute.PeriodicMutesJson[i].EnableEtime {
+ if triggerTime >= mute.PeriodicMutesJson[i].EnableStime && triggerTime < mute.PeriodicMutesJson[i].EnableEtime {
+ matchTime = true
+ break
+ }
+ } else {
+ if triggerTime < mute.PeriodicMutesJson[i].EnableStime || triggerTime >= mute.PeriodicMutesJson[i].EnableEtime {
+ matchTime = true
+ break
+ }
+ }
+ }
}
}
- return true
+ if !matchTime {
+ return false
+ }
+
+ return common.MatchTags(event.TagsMap, mute.ITags)
}
diff --git a/alert/naming/hashring.go b/alert/naming/hashring.go
new file mode 100644
index 0000000000000000000000000000000000000000..87e6569b4aaceaacccbbf6e78a32c7d61aca4345
--- /dev/null
+++ b/alert/naming/hashring.go
@@ -0,0 +1,64 @@
+package naming
+
+import (
+ "sync"
+
+ "github.com/toolkits/pkg/consistent"
+ "github.com/toolkits/pkg/logger"
+)
+
+const NodeReplicas = 500
+
+type DatasourceHashRingType struct {
+ sync.RWMutex
+ Rings map[int64]*consistent.Consistent
+}
+
+// for alert_rule sharding
+var DatasourceHashRing = DatasourceHashRingType{Rings: make(map[int64]*consistent.Consistent)}
+
+func NewConsistentHashRing(replicas int32, nodes []string) *consistent.Consistent {
+ ret := consistent.New()
+ ret.NumberOfReplicas = int(replicas)
+ for i := 0; i < len(nodes); i++ {
+ ret.Add(nodes[i])
+ }
+ return ret
+}
+
+func RebuildConsistentHashRing(datasourceId int64, nodes []string) {
+ r := consistent.New()
+ r.NumberOfReplicas = NodeReplicas
+ for i := 0; i < len(nodes); i++ {
+ r.Add(nodes[i])
+ }
+
+ DatasourceHashRing.Set(datasourceId, r)
+ logger.Infof("hash ring %d rebuild %+v", datasourceId, r.Members())
+}
+
+func (chr *DatasourceHashRingType) GetNode(datasourceId int64, pk string) (string, error) {
+ chr.RLock()
+ defer chr.RUnlock()
+ _, exists := chr.Rings[datasourceId]
+ if !exists {
+ chr.Rings[datasourceId] = NewConsistentHashRing(int32(NodeReplicas), []string{})
+ }
+
+ return chr.Rings[datasourceId].Get(pk)
+}
+
+func (chr *DatasourceHashRingType) IsHit(datasourceId int64, pk string, currentNode string) bool {
+ node, err := chr.GetNode(datasourceId, pk)
+ if err != nil {
+ logger.Debugf("datasource id:%d pk:%s failed to get node from hashring:%v", datasourceId, pk, err)
+ return false
+ }
+ return node == currentNode
+}
+
+func (chr *DatasourceHashRingType) Set(datasourceId int64, r *consistent.Consistent) {
+ chr.RLock()
+ defer chr.RUnlock()
+ chr.Rings[datasourceId] = r
+}
diff --git a/alert/naming/heartbeat.go b/alert/naming/heartbeat.go
new file mode 100644
index 0000000000000000000000000000000000000000..d21c8a6a2e8e515088fe23ffec69c026bb6a7a21
--- /dev/null
+++ b/alert/naming/heartbeat.go
@@ -0,0 +1,128 @@
+package naming
+
+import (
+ "fmt"
+ "sort"
+ "strings"
+ "time"
+
+ "github.com/ccfos/nightingale/v6/alert/aconf"
+ "github.com/ccfos/nightingale/v6/models"
+ "github.com/ccfos/nightingale/v6/pkg/ctx"
+
+ "github.com/toolkits/pkg/logger"
+)
+
+type Naming struct {
+ ctx *ctx.Context
+ Heartbeat aconf.HeartbeatConfig
+}
+
+func NewNaming(ctx *ctx.Context, heartbeat aconf.HeartbeatConfig) *Naming {
+ naming := &Naming{
+ ctx: ctx,
+ Heartbeat: heartbeat,
+ }
+ naming.Heartbeats()
+ return naming
+}
+
+// local servers
+var localss map[int64]string
+
+func (n *Naming) Heartbeats() error {
+ localss = make(map[int64]string)
+ if err := n.heartbeat(); err != nil {
+ fmt.Println("failed to heartbeat:", err)
+ return err
+ }
+
+ go n.loopHeartbeat()
+ go n.loopDeleteInactiveInstances()
+ return nil
+}
+
+func (n *Naming) loopDeleteInactiveInstances() {
+ interval := time.Duration(10) * time.Minute
+ for {
+ time.Sleep(interval)
+ n.DeleteInactiveInstances()
+ }
+}
+
+func (n *Naming) DeleteInactiveInstances() {
+ err := models.DB(n.ctx).Where("clock < ?", time.Now().Unix()-600).Delete(new(models.AlertingEngines)).Error
+ if err != nil {
+ logger.Errorf("delete inactive instances err:%v", err)
+ }
+}
+
+func (n *Naming) loopHeartbeat() {
+ interval := time.Duration(n.Heartbeat.Interval) * time.Millisecond
+ for {
+ time.Sleep(interval)
+ if err := n.heartbeat(); err != nil {
+ logger.Warning(err)
+ }
+ }
+}
+
+func (n *Naming) heartbeat() error {
+ var datasourceIds []int64
+ var err error
+
+ // 在页面上维护实例和集群的对应关系
+ datasourceIds, err = models.GetDatasourceIdsByClusterName(n.ctx, n.Heartbeat.ClusterName)
+ if err != nil {
+ return err
+ }
+
+ if len(datasourceIds) == 0 {
+ err := models.AlertingEngineHeartbeatWithCluster(n.ctx, n.Heartbeat.Endpoint, n.Heartbeat.ClusterName, 0)
+ if err != nil {
+ logger.Warningf("heartbeat with cluster %s err:%v", "", err)
+ }
+ } else {
+ for i := 0; i < len(datasourceIds); i++ {
+ err := models.AlertingEngineHeartbeatWithCluster(n.ctx, n.Heartbeat.Endpoint, n.Heartbeat.ClusterName, datasourceIds[i])
+ if err != nil {
+ logger.Warningf("heartbeat with cluster %d err:%v", datasourceIds[i], err)
+ }
+ }
+ }
+
+ for i := 0; i < len(datasourceIds); i++ {
+ servers, err := n.ActiveServers(datasourceIds[i])
+ if err != nil {
+ logger.Warningf("hearbeat %d get active server err:%v", datasourceIds[i], err)
+ continue
+ }
+
+ sort.Strings(servers)
+ newss := strings.Join(servers, " ")
+
+ oldss, exists := localss[datasourceIds[i]]
+ if exists && oldss == newss {
+ continue
+ }
+
+ RebuildConsistentHashRing(datasourceIds[i], servers)
+ localss[datasourceIds[i]] = newss
+ }
+
+ return nil
+}
+
+func (n *Naming) ActiveServers(datasourceId int64) ([]string, error) {
+ if datasourceId == -1 {
+ return nil, fmt.Errorf("cluster is empty")
+ }
+
+ // 30秒内有心跳，就认为是活的
+ return models.AlertingEngineGetsInstances(n.ctx, "datasource_id = ? and clock > ?", datasourceId, time.Now().Unix()-30)
+}
+
+func (n *Naming) AllActiveServers() ([]string, error) {
+ // 30秒内有心跳，就认为是活的
+ return models.AlertingEngineGetsInstances(n.ctx, "clock > ?", time.Now().Unix()-30)
+}
diff --git a/src/server/naming/leader.go b/alert/naming/leader.go
similarity index 50%
rename from src/server/naming/leader.go
rename to alert/naming/leader.go
index 94b080eebbe90d3b0eacbe641f195d7d7d9994d9..15192c9a13a9881190d1b89fb19505c164ea6752 100644
--- a/src/server/naming/leader.go
+++ b/alert/naming/leader.go
@@ -3,23 +3,22 @@ package naming
import (
"sort"
- "github.com/didi/nightingale/v5/src/server/config"
"github.com/toolkits/pkg/logger"
)
-func IamLeader(cluster string) (bool, error) {
- servers, err := ActiveServers(cluster)
+func (n *Naming) IamLeader() bool {
+ servers, err := n.AllActiveServers()
if err != nil {
logger.Errorf("failed to get active servers: %v", err)
- return false, err
+ return false
}
if len(servers) == 0 {
logger.Errorf("active servers empty")
- return false, err
+ return false
}
sort.Strings(servers)
- return config.C.Heartbeat.Endpoint == servers[0], nil
+ return n.Heartbeat.Endpoint == servers[0]
}
diff --git a/alert/process/alert_cur_event.go b/alert/process/alert_cur_event.go
new file mode 100644
index 0000000000000000000000000000000000000000..651ee229a479a733fcac05f8e5dcc2eca1d6856b
--- /dev/null
+++ b/alert/process/alert_cur_event.go
@@ -0,0 +1,74 @@
+package process
+
+import (
+ "sync"
+
+ "github.com/ccfos/nightingale/v6/models"
+)
+
+type AlertCurEventMap struct {
+ sync.RWMutex
+ Data map[string]*models.AlertCurEvent
+}
+
+func NewAlertCurEventMap(data map[string]*models.AlertCurEvent) *AlertCurEventMap {
+ if data == nil {
+ return &AlertCurEventMap{
+ Data: make(map[string]*models.AlertCurEvent),
+ }
+ }
+ return &AlertCurEventMap{
+ Data: data,
+ }
+}
+
+func (a *AlertCurEventMap) SetAll(data map[string]*models.AlertCurEvent) {
+ a.Lock()
+ defer a.Unlock()
+ a.Data = data
+}
+
+func (a *AlertCurEventMap) Set(key string, value *models.AlertCurEvent) {
+ a.Lock()
+ defer a.Unlock()
+ a.Data[key] = value
+}
+
+func (a *AlertCurEventMap) Get(key string) (*models.AlertCurEvent, bool) {
+ a.RLock()
+ defer a.RUnlock()
+ event, exists := a.Data[key]
+ return event, exists
+}
+
+func (a *AlertCurEventMap) UpdateLastEvalTime(key string, lastEvalTime int64) {
+ a.Lock()
+ defer a.Unlock()
+ event, exists := a.Data[key]
+ if !exists {
+ return
+ }
+ event.LastEvalTime = lastEvalTime
+}
+
+func (a *AlertCurEventMap) Delete(key string) {
+ a.Lock()
+ defer a.Unlock()
+ delete(a.Data, key)
+}
+
+func (a *AlertCurEventMap) Keys() []string {
+ a.RLock()
+ defer a.RUnlock()
+ keys := make([]string, 0, len(a.Data))
+ for k := range a.Data {
+ keys = append(keys, k)
+ }
+ return keys
+}
+
+func (a *AlertCurEventMap) GetAll() map[string]*models.AlertCurEvent {
+ a.RLock()
+ defer a.RUnlock()
+ return a.Data
+}
diff --git a/alert/process/process.go b/alert/process/process.go
new file mode 100644
index 0000000000000000000000000000000000000000..bc1bc54ed0288387df2cfab527b07ad6fe0a6126
--- /dev/null
+++ b/alert/process/process.go
@@ -0,0 +1,430 @@
+package process
+
+import (
+ "bytes"
+ "fmt"
+ "html/template"
+ "sort"
+ "strings"
+ "sync"
+ "time"
+
+ "github.com/ccfos/nightingale/v6/alert/astats"
+ "github.com/ccfos/nightingale/v6/alert/common"
+ "github.com/ccfos/nightingale/v6/alert/dispatch"
+ "github.com/ccfos/nightingale/v6/alert/mute"
+ "github.com/ccfos/nightingale/v6/alert/queue"
+ "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/tplx"
+ "github.com/ccfos/nightingale/v6/prom"
+ "github.com/toolkits/pkg/logger"
+ "github.com/toolkits/pkg/str"
+)
+
+type ExternalProcessorsType struct {
+ ExternalLock sync.RWMutex
+ Processors map[string]*Processor
+}
+
+var ExternalProcessors ExternalProcessorsType
+
+func NewExternalProcessors() *ExternalProcessorsType {
+ return &ExternalProcessorsType{
+ Processors: make(map[string]*Processor),
+ }
+}
+
+func (e *ExternalProcessorsType) GetExternalAlertRule(datasourceId, id int64) (*Processor, bool) {
+ e.ExternalLock.RLock()
+ defer e.ExternalLock.RUnlock()
+ processor, has := e.Processors[common.RuleKey(datasourceId, id)]
+ return processor, has
+}
+
+type Processor struct {
+ datasourceId int64
+ quit chan struct{}
+
+ rule *models.AlertRule
+ fires *AlertCurEventMap
+ pendings *AlertCurEventMap
+ inhibit bool
+
+ tagsMap map[string]string
+ tagsArr []string
+ target string
+ targetNote string
+ groupName string
+
+ atertRuleCache *memsto.AlertRuleCacheType
+ targetCache *memsto.TargetCacheType
+ busiGroupCache *memsto.BusiGroupCacheType
+ alertMuteCache *memsto.AlertMuteCacheType
+
+ promClients *prom.PromClientMap
+ ctx *ctx.Context
+ stats *astats.Stats
+}
+
+func (arw *Processor) Key() string {
+ return common.RuleKey(arw.datasourceId, arw.rule.Id)
+}
+
+func (arw *Processor) Hash() string {
+ return str.MD5(fmt.Sprintf("%d_%d_%s_%d",
+ arw.rule.Id,
+ arw.rule.PromEvalInterval,
+ arw.rule.RuleConfig,
+ arw.datasourceId,
+ ))
+}
+
+func NewProcessor(rule *models.AlertRule, datasourceId int64, atertRuleCache *memsto.AlertRuleCacheType, targetCache *memsto.TargetCacheType,
+ busiGroupCache *memsto.BusiGroupCacheType, alertMuteCache *memsto.AlertMuteCacheType, promClients *prom.PromClientMap, ctx *ctx.Context,
+ stats *astats.Stats) *Processor {
+
+ arw := &Processor{
+ datasourceId: datasourceId,
+ quit: make(chan struct{}),
+ rule: rule,
+
+ targetCache: targetCache,
+ busiGroupCache: busiGroupCache,
+ alertMuteCache: alertMuteCache,
+ atertRuleCache: atertRuleCache,
+
+ promClients: promClients,
+ ctx: ctx,
+ stats: stats,
+ }
+
+ arw.mayHandleGroup()
+ return arw
+}
+
+func (arw *Processor) Handle(anomalyPoints []common.AnomalyPoint, from string, inhibit bool) {
+ // 有可能rule的一些配置已经发生变化，比如告警接收人、callbacks等
+ // 这些信息的修改是不会引起worker restart的，但是确实会影响告警处理逻辑
+ // 所以，这里直接从memsto.AlertRuleCache中获取并覆盖
+ arw.inhibit = inhibit
+ arw.rule = arw.atertRuleCache.Get(arw.rule.Id)
+ cachedRule := arw.rule
+ if cachedRule == nil {
+ logger.Errorf("rule_eval:%s rule not found", arw.Key())
+ return
+ }
+
+ now := time.Now().Unix()
+ alertingKeys := map[string]struct{}{}
+
+ // 根据 event 的 tag 将 events 分组，处理告警抑制的情况
+ eventsMap := make(map[string][]*models.AlertCurEvent)
+ for _, anomalyPoint := range anomalyPoints {
+ event := arw.BuildEvent(anomalyPoint, from, now)
+ // 如果 event 被 mute 了,本质也是 fire 的状态,这里无论如何都添加到 alertingKeys 中,防止 fire 的事件自动恢复了
+ hash := event.Hash
+ alertingKeys[hash] = struct{}{}
+ if mute.IsMuted(cachedRule, event, arw.targetCache, arw.alertMuteCache) {
+ logger.Debugf("rule_eval:%s event:%v is muted", arw.Key(), event)
+ continue
+ }
+ tagHash := TagHash(anomalyPoint)
+ eventsMap[tagHash] = append(eventsMap[tagHash], event)
+ }
+
+ for _, events := range eventsMap {
+ arw.handleEvent(events)
+ }
+
+ arw.HandleRecover(alertingKeys, now)
+}
+
+func (arw *Processor) BuildEvent(anomalyPoint common.AnomalyPoint, from string, now int64) *models.AlertCurEvent {
+ arw.fillTags(anomalyPoint)
+ arw.mayHandleIdent()
+ hash := Hash(arw.rule.Id, arw.datasourceId, anomalyPoint)
+
+ event := arw.rule.GenerateNewEvent(arw.ctx)
+ event.TriggerTime = anomalyPoint.Timestamp
+ event.TagsMap = arw.tagsMap
+ event.DatasourceId = arw.datasourceId
+ event.Hash = hash
+ event.TargetIdent = arw.target
+ event.TargetNote = arw.targetNote
+ event.TriggerValue = anomalyPoint.ReadableValue()
+ event.TagsJSON = arw.tagsArr
+ event.GroupName = arw.groupName
+ event.Tags = strings.Join(arw.tagsArr, ",,")
+ event.IsRecovered = false
+ event.Callbacks = arw.rule.Callbacks
+ event.CallbacksJSON = arw.rule.CallbacksJSON
+ event.Annotations = arw.rule.Annotations
+ event.AnnotationsJSON = arw.rule.AnnotationsJSON
+ event.RuleConfig = arw.rule.RuleConfig
+ event.RuleConfigJson = arw.rule.RuleConfigJson
+ event.Severity = anomalyPoint.Severity
+
+ if from == "inner" {
+ event.LastEvalTime = now
+ } else {
+ event.LastEvalTime = event.TriggerTime
+ }
+ return event
+}
+
+func (arw *Processor) HandleRecover(alertingKeys map[string]struct{}, now int64) {
+ for _, hash := range arw.pendings.Keys() {
+ if _, has := alertingKeys[hash]; has {
+ continue
+ }
+ arw.pendings.Delete(hash)
+ }
+
+ for hash := range arw.fires.GetAll() {
+ if _, has := alertingKeys[hash]; has {
+ continue
+ }
+ arw.RecoverSingle(hash, now, nil)
+ }
+}
+
+func (arw *Processor) RecoverSingle(hash string, now int64, value *string) {
+ cachedRule := arw.rule
+ if cachedRule == nil {
+ return
+ }
+ event, has := arw.fires.Get(hash)
+ if !has {
+ return
+ }
+ // 如果配置了留观时长，就不能立马恢复了
+ if cachedRule.RecoverDuration > 0 && now-event.LastEvalTime < cachedRule.RecoverDuration {
+ logger.Debugf("rule_eval:%s event:%v not recover", arw.Key(), event)
+ return
+ }
+ if value != nil {
+ event.TriggerValue = *value
+ }
+
+ // 没查到触发阈值的vector，姑且就认为这个vector的值恢复了
+ // 我确实无法分辨，是prom中有值但是未满足阈值所以没返回，还是prom中确实丢了一些点导致没有数据可以返回，尴尬
+ arw.fires.Delete(hash)
+ arw.pendings.Delete(hash)
+
+ // 可能是因为调整了promql才恢复的，所以事件里边要体现最新的promql，否则用户会比较困惑
+ // 当然，其实rule的各个字段都可能发生变化了，都更新一下吧
+ cachedRule.UpdateEvent(event)
+ event.IsRecovered = true
+ event.LastEvalTime = now
+ arw.pushEventToQueue(event)
+}
+
+func (arw *Processor) handleEvent(events []*models.AlertCurEvent) {
+ var fireEvents []*models.AlertCurEvent
+ // severity 初始为 4, 一定为遇到比自己优先级高的事件
+ severity := 4
+ for _, event := range events {
+ if event == nil {
+ continue
+ }
+ if arw.rule.PromForDuration == 0 {
+ fireEvents = append(fireEvents, event)
+ if severity > event.Severity {
+ severity = event.Severity
+ }
+ continue
+ }
+
+ var preTriggerTime int64
+ preEvent, has := arw.pendings.Get(event.Hash)
+ if has {
+ arw.pendings.UpdateLastEvalTime(event.Hash, event.LastEvalTime)
+ preTriggerTime = preEvent.TriggerTime
+ } else {
+ arw.pendings.Set(event.Hash, event)
+ preTriggerTime = event.TriggerTime
+ }
+
+ if event.LastEvalTime-preTriggerTime+int64(event.PromEvalInterval) >= int64(arw.rule.PromForDuration) {
+ fireEvents = append(fireEvents, event)
+ if severity > event.Severity {
+ severity = event.Severity
+ }
+ continue
+ }
+ }
+
+ arw.inhibitEvent(fireEvents, severity)
+}
+
+func (arw *Processor) inhibitEvent(events []*models.AlertCurEvent, highSeverity int) {
+ for _, event := range events {
+ if arw.inhibit && event.Severity > highSeverity {
+ logger.Debugf("rule_eval:%s event:%+v inhibit highSeverity:%d", arw.Key(), event, highSeverity)
+ continue
+ }
+ arw.fireEvent(event)
+ }
+}
+
+func (arw *Processor) fireEvent(event *models.AlertCurEvent) {
+ // As arw.rule maybe outdated, use rule from cache
+ cachedRule := arw.rule
+ if cachedRule == nil {
+ return
+ }
+ logger.Debugf("rule_eval:%s event:%+v fire", arw.Key(), event)
+ if fired, has := arw.fires.Get(event.Hash); has {
+ arw.fires.UpdateLastEvalTime(event.Hash, event.LastEvalTime)
+
+ if cachedRule.NotifyRepeatStep == 0 {
+ logger.Debugf("rule_eval:%s event:%+v repeat is zero nothing to do", arw.Key(), event)
+ // 说明不想重复通知，那就直接返回了，nothing to do
+ // do not need to send alert again
+ return
+ }
+
+ // 之前发送过告警了，这次是否要继续发送，要看是否过了通道静默时间
+ if event.LastEvalTime > fired.LastSentTime+int64(cachedRule.NotifyRepeatStep)*60 {
+ if cachedRule.NotifyMaxNumber == 0 {
+ // 最大可以发送次数如果是0，表示不想限制最大发送次数，一直发即可
+ event.NotifyCurNumber = fired.NotifyCurNumber + 1
+ event.FirstTriggerTime = fired.FirstTriggerTime
+ arw.pushEventToQueue(event)
+ } else {
+ // 有最大发送次数的限制，就要看已经发了几次了，是否达到了最大发送次数
+ if fired.NotifyCurNumber >= cachedRule.NotifyMaxNumber {
+ logger.Debugf("rule_eval:%s event:%+v reach max number", arw.Key(), event)
+ return
+ } else {
+ event.NotifyCurNumber = fired.NotifyCurNumber + 1
+ event.FirstTriggerTime = fired.FirstTriggerTime
+ arw.pushEventToQueue(event)
+ }
+ }
+ }
+ } else {
+ event.NotifyCurNumber = 1
+ event.FirstTriggerTime = event.TriggerTime
+ arw.pushEventToQueue(event)
+ }
+}
+
+func (arw *Processor) pushEventToQueue(e *models.AlertCurEvent) {
+ if !e.IsRecovered {
+ e.LastSentTime = e.LastEvalTime
+ arw.fires.Set(e.Hash, e)
+ }
+
+ arw.stats.CounterAlertsTotal.WithLabelValues(fmt.Sprintf("%d", e.DatasourceId)).Inc()
+ dispatch.LogEvent(e, "push_queue")
+ if !queue.EventQueue.PushFront(e) {
+ logger.Warningf("event_push_queue: queue is full, event:%+v", e)
+ }
+}
+
+func (arw *Processor) RecoverAlertCurEventFromDb() {
+ arw.pendings = NewAlertCurEventMap(nil)
+
+ curEvents, err := models.AlertCurEventGetByRuleIdAndCluster(arw.ctx, arw.rule.Id, arw.datasourceId)
+ if err != nil {
+ logger.Errorf("recover event from db for rule:%s failed, err:%s", arw.Key(), err)
+ arw.fires = NewAlertCurEventMap(nil)
+ return
+ }
+
+ fireMap := make(map[string]*models.AlertCurEvent)
+ for _, event := range curEvents {
+ event.DB2Mem()
+ fireMap[event.Hash] = event
+ }
+
+ arw.fires = NewAlertCurEventMap(fireMap)
+}
+
+func (arw *Processor) fillTags(anomalyPoint common.AnomalyPoint) {
+ // handle series tags
+ tagsMap := make(map[string]string)
+ for label, value := range anomalyPoint.Labels {
+ tagsMap[string(label)] = string(value)
+ }
+
+ var e = &models.AlertCurEvent{
+ TagsMap: tagsMap,
+ }
+
+ // handle rule tags
+ for _, tag := range arw.rule.AppendTagsJSON {
+ arr := strings.SplitN(tag, "=", 2)
+
+ var defs = []string{
+ "{{$labels := .TagsMap}}",
+ "{{$value := .TriggerValue}}",
+ }
+ tagValue := arr[1]
+ text := strings.Join(append(defs, tagValue), "")
+ t, err := template.New(fmt.Sprint(arw.rule.Id)).Funcs(template.FuncMap(tplx.TemplateFuncMap)).Parse(text)
+ if err != nil {
+ tagValue = fmt.Sprintf("parse tag value failed, err:%s", err)
+ }
+
+ var body bytes.Buffer
+ err = t.Execute(&body, e)
+ if err != nil {
+ tagValue = fmt.Sprintf("parse tag value failed, err:%s", err)
+ }
+
+ if err == nil {
+ tagValue = body.String()
+ }
+ tagsMap[arr[0]] = tagValue
+ }
+
+ tagsMap["rulename"] = arw.rule.Name
+ arw.tagsMap = tagsMap
+
+ // handle tagsArr
+ arw.tagsArr = labelMapToArr(tagsMap)
+}
+
+func (arw *Processor) mayHandleIdent() {
+ // handle ident
+ if ident, has := arw.tagsMap["ident"]; has {
+ if target, exists := arw.targetCache.Get(ident); exists {
+ arw.target = target.Ident
+ arw.targetNote = target.Note
+ }
+ }
+}
+
+func (arw *Processor) mayHandleGroup() {
+ // handle bg
+ bg := arw.busiGroupCache.GetByBusiGroupId(arw.rule.GroupId)
+ if bg != nil {
+ arw.groupName = bg.Name
+ }
+}
+
+func labelMapToArr(m map[string]string) []string {
+ numLabels := len(m)
+
+ labelStrings := make([]string, 0, numLabels)
+ for label, value := range m {
+ labelStrings = append(labelStrings, fmt.Sprintf("%s=%s", label, value))
+ }
+
+ if numLabels > 1 {
+ sort.Strings(labelStrings)
+ }
+ return labelStrings
+}
+
+func Hash(ruleId, datasourceId int64, vector common.AnomalyPoint) string {
+ return str.MD5(fmt.Sprintf("%d_%s_%d_%d", ruleId, vector.Labels.String(), datasourceId, vector.Severity))
+}
+
+func TagHash(vector common.AnomalyPoint) string {
+ return str.MD5(vector.Labels.String())
+}
diff --git a/alert/queue/queue.go b/alert/queue/queue.go
new file mode 100644
index 0000000000000000000000000000000000000000..ea2218b876073cedbe27f4d0da4a0a9e6a0f6003
--- /dev/null
+++ b/alert/queue/queue.go
@@ -0,0 +1,18 @@
+package queue
+
+import (
+ "time"
+
+ "github.com/ccfos/nightingale/v6/alert/astats"
+ "github.com/toolkits/pkg/container/list"
+)
+
+var EventQueue = list.NewSafeListLimited(10000000)
+
+func ReportQueueSize(stats *astats.Stats) {
+ for {
+ time.Sleep(time.Second)
+
+ stats.GaugeAlertQueueSize.Set(float64(EventQueue.Len()))
+ }
+}
diff --git a/src/server/engine/rule_record.go b/alert/record/prom_rule.go
similarity index 54%
rename from src/server/engine/rule_record.go
rename to alert/record/prom_rule.go
index 1043543d2a35ec6547977e94dbd3618c34bf4ee9..433fe58312c8756e3cee379965f816970a66a770 100644
--- a/src/server/engine/rule_record.go
+++ b/alert/record/prom_rule.go
@@ -1,4 +1,4 @@
-package engine
+package record
import (
"context"
@@ -6,40 +6,43 @@ import (
"strings"
"time"
+ "github.com/ccfos/nightingale/v6/models"
+ "github.com/ccfos/nightingale/v6/prom"
+ "github.com/ccfos/nightingale/v6/pushgw/writer"
+
"github.com/toolkits/pkg/logger"
"github.com/toolkits/pkg/str"
-
- "github.com/didi/nightingale/v5/src/models"
- "github.com/didi/nightingale/v5/src/server/common/conv"
- "github.com/didi/nightingale/v5/src/server/config"
- "github.com/didi/nightingale/v5/src/server/writer"
)
type RecordRuleContext struct {
- cluster string
- quit chan struct{}
+ datasourceId int64
+ quit chan struct{}
rule *models.RecordingRule
+ // writers *writer.WritersType
+ promClients *prom.PromClientMap
}
-func NewRecordRuleContext(rule *models.RecordingRule, cluster string) *RecordRuleContext {
+func NewRecordRuleContext(rule *models.RecordingRule, datasourceId int64, promClients *prom.PromClientMap, writers *writer.WritersType) *RecordRuleContext {
return &RecordRuleContext{
- cluster: cluster,
- quit: make(chan struct{}),
- rule: rule,
+ datasourceId: datasourceId,
+ quit: make(chan struct{}),
+ rule: rule,
+ promClients: promClients,
+ //writers: writers,
}
}
func (rrc *RecordRuleContext) Key() string {
- return fmt.Sprintf("record-%s-%d", rrc.cluster, rrc.rule.Id)
+ return fmt.Sprintf("record-%d-%d", rrc.datasourceId, rrc.rule.Id)
}
func (rrc *RecordRuleContext) Hash() string {
- return str.MD5(fmt.Sprintf("%d_%d_%s_%s",
+ return str.MD5(fmt.Sprintf("%d_%d_%s_%d",
rrc.rule.Id,
rrc.rule.PromEvalInterval,
rrc.rule.PromQl,
- rrc.cluster,
+ rrc.datasourceId,
))
}
@@ -71,26 +74,25 @@ func (rrc *RecordRuleContext) Eval() {
return
}
- if config.ReaderClients.IsNil(rrc.cluster) {
+ if rrc.promClients.IsNil(rrc.datasourceId) {
logger.Errorf("eval:%s reader client is nil", rrc.Key())
return
}
- value, warnings, err := config.ReaderClients.GetCli(rrc.cluster).Query(context.Background(), promql, time.Now())
+ value, warnings, err := rrc.promClients.GetCli(rrc.datasourceId).Query(context.Background(), promql, time.Now())
if err != nil {
- logger.Errorf("eval:%d promql:%s, error:%v", rrc.Key(), promql, err)
+ logger.Errorf("eval:%s promql:%s, error:%v", rrc.Key(), promql, err)
return
}
if len(warnings) > 0 {
- logger.Errorf("eval:%d promql:%s, warnings:%v", rrc.Key(), promql, warnings)
+ logger.Errorf("eval:%s promql:%s, warnings:%v", rrc.Key(), promql, warnings)
return
}
- ts := conv.ConvertToTimeSeries(value, rrc.rule)
+
+ ts := ConvertToTimeSeries(value, rrc.rule)
if len(ts) != 0 {
- for _, v := range ts {
- writer.Writers.PushSample(rrc.rule.Name, v, rrc.cluster)
- }
+ rrc.promClients.GetWriterCli(rrc.datasourceId).Write(ts)
}
}
diff --git a/src/server/common/conv/sample.go b/alert/record/sample.go
similarity index 97%
rename from src/server/common/conv/sample.go
rename to alert/record/sample.go
index 97c1c15415987b476948becdaf7b898568a61aee..56e2870bdddf51d2dc10353a30ba8ef0b07595d0 100644
--- a/src/server/common/conv/sample.go
+++ b/alert/record/sample.go
@@ -1,11 +1,12 @@
-package conv
+package record
import (
"math"
"strings"
"time"
- "github.com/didi/nightingale/v5/src/models"
+ "github.com/ccfos/nightingale/v6/models"
+
"github.com/prometheus/common/model"
"github.com/prometheus/prometheus/prompb"
)
diff --git a/alert/record/scheduler.go b/alert/record/scheduler.go
new file mode 100644
index 0000000000000000000000000000000000000000..bf43d3454aca9e6663add27065744469483bd2a8
--- /dev/null
+++ b/alert/record/scheduler.go
@@ -0,0 +1,94 @@
+package record
+
+import (
+ "context"
+ "fmt"
+ "time"
+
+ "github.com/ccfos/nightingale/v6/alert/aconf"
+ "github.com/ccfos/nightingale/v6/alert/astats"
+ "github.com/ccfos/nightingale/v6/alert/naming"
+ "github.com/ccfos/nightingale/v6/memsto"
+ "github.com/ccfos/nightingale/v6/prom"
+ "github.com/ccfos/nightingale/v6/pushgw/writer"
+)
+
+type Scheduler struct {
+ // key: hash
+ recordRules map[string]*RecordRuleContext
+
+ aconf aconf.Alert
+
+ recordingRuleCache *memsto.RecordingRuleCacheType
+
+ promClients *prom.PromClientMap
+ writers *writer.WritersType
+
+ stats *astats.Stats
+}
+
+func NewScheduler(aconf aconf.Alert, rrc *memsto.RecordingRuleCacheType, promClients *prom.PromClientMap, writers *writer.WritersType, stats *astats.Stats) *Scheduler {
+ scheduler := &Scheduler{
+ aconf: aconf,
+ recordRules: make(map[string]*RecordRuleContext),
+
+ recordingRuleCache: rrc,
+
+ promClients: promClients,
+ writers: writers,
+
+ stats: stats,
+ }
+
+ go scheduler.LoopSyncRules(context.Background())
+ return scheduler
+}
+
+func (s *Scheduler) LoopSyncRules(ctx context.Context) {
+ time.Sleep(time.Duration(s.aconf.EngineDelay) * time.Second)
+ duration := 9000 * time.Millisecond
+ for {
+ select {
+ case <-ctx.Done():
+ return
+ case <-time.After(duration):
+ s.syncRecordRules()
+ }
+ }
+}
+
+func (s *Scheduler) syncRecordRules() {
+ ids := s.recordingRuleCache.GetRuleIds()
+ recordRules := make(map[string]*RecordRuleContext)
+ for _, id := range ids {
+ rule := s.recordingRuleCache.Get(id)
+ if rule == nil {
+ continue
+ }
+
+ datasourceIds := s.promClients.Hit(rule.DatasourceIdsJson)
+ for _, dsId := range datasourceIds {
+ if !naming.DatasourceHashRing.IsHit(dsId, fmt.Sprintf("%d", rule.Id), s.aconf.Heartbeat.Endpoint) {
+ continue
+ }
+
+ recordRule := NewRecordRuleContext(rule, dsId, s.promClients, s.writers)
+ recordRules[recordRule.Hash()] = recordRule
+ }
+ }
+
+ for hash, rule := range recordRules {
+ if _, has := s.recordRules[hash]; !has {
+ rule.Prepare()
+ rule.Start()
+ s.recordRules[hash] = rule
+ }
+ }
+
+ for hash, rule := range s.recordRules {
+ if _, has := recordRules[hash]; !has {
+ rule.Stop()
+ delete(s.recordRules, hash)
+ }
+ }
+}
diff --git a/alert/router/router.go b/alert/router/router.go
new file mode 100644
index 0000000000000000000000000000000000000000..4cdaa69156e41dad19ee2c9e290b67d709fd2409
--- /dev/null
+++ b/alert/router/router.go
@@ -0,0 +1,71 @@
+package router
+
+import (
+ "net/http"
+
+ "github.com/ccfos/nightingale/v6/alert/aconf"
+ "github.com/ccfos/nightingale/v6/alert/astats"
+ "github.com/ccfos/nightingale/v6/alert/process"
+ "github.com/ccfos/nightingale/v6/memsto"
+ "github.com/ccfos/nightingale/v6/pkg/ctx"
+ "github.com/ccfos/nightingale/v6/pkg/httpx"
+
+ "github.com/gin-gonic/gin"
+)
+
+type Router struct {
+ HTTP httpx.Config
+ Alert aconf.Alert
+ AlertMuteCache *memsto.AlertMuteCacheType
+ TargetCache *memsto.TargetCacheType
+ BusiGroupCache *memsto.BusiGroupCacheType
+ AlertStats *astats.Stats
+ Ctx *ctx.Context
+ ExternalProcessors *process.ExternalProcessorsType
+}
+
+func New(httpConfig httpx.Config, alert aconf.Alert, amc *memsto.AlertMuteCacheType, tc *memsto.TargetCacheType, bgc *memsto.BusiGroupCacheType,
+ astats *astats.Stats, ctx *ctx.Context, externalProcessors *process.ExternalProcessorsType) *Router {
+ return &Router{
+ HTTP: httpConfig,
+ Alert: alert,
+ AlertStats: astats,
+ AlertMuteCache: amc,
+ TargetCache: tc,
+ BusiGroupCache: bgc,
+ Ctx: ctx,
+ ExternalProcessors: externalProcessors,
+ }
+}
+
+func (rt *Router) Config(r *gin.Engine) {
+ service := r.Group("/v1/n9e")
+ service.POST("/event", rt.pushEventToQueue)
+ service.POST("/make-event", rt.makeEvent)
+}
+
+func Render(c *gin.Context, data, msg interface{}) {
+ if msg == nil {
+ if data == nil {
+ data = struct{}{}
+ }
+ c.JSON(http.StatusOK, gin.H{"data": data, "error": ""})
+ } else {
+ c.JSON(http.StatusOK, gin.H{"error": gin.H{"message": msg}})
+ }
+}
+
+func Dangerous(c *gin.Context, v interface{}, code ...int) {
+ if v == nil {
+ return
+ }
+
+ switch t := v.(type) {
+ case string:
+ if t != "" {
+ c.JSON(http.StatusOK, gin.H{"error": gin.H{"message": v}})
+ }
+ case error:
+ c.JSON(http.StatusOK, gin.H{"error": gin.H{"message": t.Error()}})
+ }
+}
diff --git a/src/server/router/router_event.go b/alert/router/router_event.go
similarity index 63%
rename from src/server/router/router_event.go
rename to alert/router/router_event.go
index 899dc1d2353c97a29c3bc112c3b1b1ce70658d04..e8cd47d624ef5facdd2c48e8effd1f88564ce9b4 100644
--- a/src/server/router/router_event.go
+++ b/alert/router/router_event.go
@@ -5,20 +5,21 @@ import (
"strings"
"time"
+ "github.com/ccfos/nightingale/v6/alert/common"
+ "github.com/ccfos/nightingale/v6/alert/dispatch"
+ "github.com/ccfos/nightingale/v6/alert/mute"
+ "github.com/ccfos/nightingale/v6/alert/naming"
+ "github.com/ccfos/nightingale/v6/alert/process"
+ "github.com/ccfos/nightingale/v6/alert/queue"
+ "github.com/ccfos/nightingale/v6/models"
+ "github.com/ccfos/nightingale/v6/pkg/poster"
+
"github.com/gin-gonic/gin"
"github.com/toolkits/pkg/ginx"
"github.com/toolkits/pkg/logger"
-
- "github.com/didi/nightingale/v5/src/models"
- "github.com/didi/nightingale/v5/src/pkg/poster"
- "github.com/didi/nightingale/v5/src/server/common/conv"
- "github.com/didi/nightingale/v5/src/server/config"
- "github.com/didi/nightingale/v5/src/server/engine"
- "github.com/didi/nightingale/v5/src/server/naming"
- promstat "github.com/didi/nightingale/v5/src/server/stat"
)
-func pushEventToQueue(c *gin.Context) {
+func (rt *Router) pushEventToQueue(c *gin.Context) {
var event *models.AlertCurEvent
ginx.BindJSON(c, &event)
if event.RuleId == 0 {
@@ -40,7 +41,7 @@ func pushEventToQueue(c *gin.Context) {
event.TagsMap[arr[0]] = arr[1]
}
- if engine.EventMuteStrategy(nil, event) {
+ if mute.EventMuteStrategy(event, rt.AlertMuteCache) {
logger.Infof("event_muted: rule_id=%d %s", event.RuleId, event.Hash)
ginx.NewRender(c).Message(nil)
return
@@ -54,6 +55,10 @@ func pushEventToQueue(c *gin.Context) {
event.RuleNote = fmt.Sprintf("failed to parse rule note: %v", err)
}
+ if err := event.ParseRule("annotations"); err != nil {
+ event.RuleNote = fmt.Sprintf("failed to parse rule note: %v", err)
+ }
+
// 如果 rule_note 中有 ; 前缀，则使用 rule_note 替换 tags 中的内容
if strings.HasPrefix(event.RuleNote, ";") {
event.RuleNote = strings.TrimPrefix(event.RuleNote, ";")
@@ -67,10 +72,10 @@ func pushEventToQueue(c *gin.Context) {
event.NotifyChannels = strings.Join(event.NotifyChannelsJSON, " ")
event.NotifyGroups = strings.Join(event.NotifyGroupsJSON, " ")
- promstat.CounterAlertsTotal.WithLabelValues(event.Cluster).Inc()
+ rt.AlertStats.CounterAlertsTotal.WithLabelValues(event.Cluster).Inc()
- engine.LogEvent(event, "http_push_queue")
- if !engine.EventQueue.PushFront(event) {
+ dispatch.LogEvent(event, "http_push_queue")
+ if !queue.EventQueue.PushFront(event) {
msg := fmt.Sprintf("event:%+v push_queue err: queue is full", event)
ginx.Bomb(200, msg)
logger.Warningf(msg)
@@ -79,35 +84,25 @@ func pushEventToQueue(c *gin.Context) {
}
type eventForm struct {
- Alert bool `json:"alert"`
- Vectors []conv.Vector `json:"vectors"`
- RuleId int64 `json:"rule_id"`
- Cluster string `json:"cluster"`
-}
-
-func judgeEvent(c *gin.Context) {
- var form eventForm
- ginx.BindJSON(c, &form)
- ruleContext, exists := engine.GetExternalAlertRule(form.Cluster, form.RuleId)
- if !exists {
- ginx.Bomb(200, "rule not exists")
- }
- ruleContext.HandleVectors(form.Vectors, "http")
- ginx.NewRender(c).Message(nil)
+ Alert bool `json:"alert"`
+ AnomalyPoints []common.AnomalyPoint `json:"vectors"`
+ RuleId int64 `json:"rule_id"`
+ DatasourceId int64 `json:"datasource_id"`
+ Inhibit bool `json:"inhibit"`
}
-func makeEvent(c *gin.Context) {
+func (rt *Router) makeEvent(c *gin.Context) {
var events []*eventForm
ginx.BindJSON(c, &events)
//now := time.Now().Unix()
for i := 0; i < len(events); i++ {
- node, err := naming.ClusterHashRing.GetNode(events[i].Cluster, fmt.Sprintf("%d", events[i].RuleId))
+ node, err := naming.DatasourceHashRing.GetNode(events[i].DatasourceId, fmt.Sprintf("%d", events[i].RuleId))
if err != nil {
logger.Warningf("event:%+v get node err:%v", events[i], err)
ginx.Bomb(200, "event node not exists")
}
- if node != config.C.Heartbeat.Endpoint {
+ if node != rt.Alert.Heartbeat.Endpoint {
err := forwardEvent(events[i], node)
if err != nil {
logger.Warningf("event:%+v forward err:%v", events[i], err)
@@ -116,19 +111,18 @@ func makeEvent(c *gin.Context) {
continue
}
- ruleContext, exists := engine.GetExternalAlertRule(events[i].Cluster, events[i].RuleId)
+ ruleWorker, exists := rt.ExternalProcessors.GetExternalAlertRule(events[i].DatasourceId, events[i].RuleId)
logger.Debugf("handle event:%+v exists:%v", events[i], exists)
if !exists {
ginx.Bomb(200, "rule not exists")
}
if events[i].Alert {
- go ruleContext.HandleVectors(events[i].Vectors, "http")
+ go ruleWorker.Handle(events[i].AnomalyPoints, "http", events[i].Inhibit)
} else {
- for _, vector := range events[i].Vectors {
- alertVector := engine.NewAlertVector(ruleContext, nil, vector, "http")
+ for _, vector := range events[i].AnomalyPoints {
readableString := vector.ReadableValue()
- go ruleContext.RecoverSingle(alertVector.Hash(), vector.Timestamp, &readableString)
+ go ruleWorker.RecoverSingle(process.Hash(events[i].RuleId, events[i].DatasourceId, vector), vector.Timestamp, &readableString)
}
}
}
diff --git a/src/server/common/sender/callback.go b/alert/sender/callback.go
similarity index 74%
rename from src/server/common/sender/callback.go
rename to alert/sender/callback.go
index 6a181aceb31d2b94136b9ed21d418a3dd5c6e4cc..e8ba9979eb6354918b6ae466b034a5f039861bda 100644
--- a/src/server/common/sender/callback.go
+++ b/alert/sender/callback.go
@@ -5,16 +5,17 @@ import (
"strings"
"time"
- "github.com/toolkits/pkg/logger"
+ "github.com/ccfos/nightingale/v6/alert/aconf"
+ "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/ibex"
+ "github.com/ccfos/nightingale/v6/pkg/poster"
- "github.com/didi/nightingale/v5/src/models"
- "github.com/didi/nightingale/v5/src/pkg/ibex"
- "github.com/didi/nightingale/v5/src/pkg/poster"
- "github.com/didi/nightingale/v5/src/server/config"
- "github.com/didi/nightingale/v5/src/server/memsto"
+ "github.com/toolkits/pkg/logger"
)
-func SendCallbacks(urls []string, event *models.AlertCurEvent) {
+func SendCallbacks(ctx *ctx.Context, urls []string, event *models.AlertCurEvent, targetCache *memsto.TargetCacheType, ibexConf aconf.Ibex) {
for _, url := range urls {
if url == "" {
continue
@@ -22,7 +23,7 @@ func SendCallbacks(urls []string, event *models.AlertCurEvent) {
if strings.HasPrefix(url, "${ibex}") {
if !event.IsRecovered {
- handleIbex(url, event)
+ handleIbex(ctx, url, event, targetCache, ibexConf)
}
continue
}
@@ -59,7 +60,7 @@ type TaskCreateReply struct {
Dat int64 `json:"dat"` // task.id
}
-func handleIbex(url string, event *models.AlertCurEvent) {
+func handleIbex(ctx *ctx.Context, url string, event *models.AlertCurEvent, targetCache *memsto.TargetCacheType, ibexConf aconf.Ibex) {
arr := strings.Split(url, "/")
var idstr string
@@ -89,7 +90,7 @@ func handleIbex(url string, event *models.AlertCurEvent) {
return
}
- tpl, err := models.TaskTplGet("id = ?", id)
+ tpl, err := models.TaskTplGet(ctx, "id = ?", id)
if err != nil {
logger.Errorf("event_callback_ibex: failed to get tpl: %v", err)
return
@@ -102,7 +103,7 @@ func handleIbex(url string, event *models.AlertCurEvent) {
// check perm
// tpl.GroupId - host - account 三元组校验权限
- can, err := canDoIbex(tpl.UpdateBy, tpl, host)
+ can, err := canDoIbex(ctx, tpl.UpdateBy, tpl, host, targetCache)
if err != nil {
logger.Errorf("event_callback_ibex: check perm fail: %v", err)
return
@@ -130,10 +131,10 @@ func handleIbex(url string, event *models.AlertCurEvent) {
var res TaskCreateReply
err = ibex.New(
- config.C.Ibex.Address,
- config.C.Ibex.BasicAuthUser,
- config.C.Ibex.BasicAuthPass,
- config.C.Ibex.Timeout,
+ ibexConf.Address,
+ ibexConf.BasicAuthUser,
+ ibexConf.BasicAuthPass,
+ ibexConf.Timeout,
).
Path("/ibex/v1/tasks").
In(in).
@@ -154,9 +155,9 @@ func handleIbex(url string, event *models.AlertCurEvent) {
record := models.TaskRecord{
Id: res.Dat,
GroupId: tpl.GroupId,
- IbexAddress: config.C.Ibex.Address,
- IbexAuthUser: config.C.Ibex.BasicAuthUser,
- IbexAuthPass: config.C.Ibex.BasicAuthPass,
+ IbexAddress: ibexConf.Address,
+ IbexAuthUser: ibexConf.BasicAuthUser,
+ IbexAuthPass: ibexConf.BasicAuthPass,
Title: in.Title,
Account: in.Account,
Batch: in.Batch,
@@ -169,13 +170,13 @@ func handleIbex(url string, event *models.AlertCurEvent) {
CreateBy: in.Creator,
}
- if err = record.Add(); err != nil {
+ if err = record.Add(ctx); err != nil {
logger.Errorf("event_callback_ibex: persist task_record fail: %v", err)
}
}
-func canDoIbex(username string, tpl *models.TaskTpl, host string) (bool, error) {
- user, err := models.UserGetByUsername(username)
+func canDoIbex(ctx *ctx.Context, username string, tpl *models.TaskTpl, host string, targetCache *memsto.TargetCacheType) (bool, error) {
+ user, err := models.UserGetByUsername(ctx, username)
if err != nil {
return false, err
}
@@ -184,7 +185,7 @@ func canDoIbex(username string, tpl *models.TaskTpl, host string) (bool, error)
return true, nil
}
- target, has := memsto.TargetCache.Get(host)
+ target, has := targetCache.Get(host)
if !has {
return false, nil
}
diff --git a/src/server/common/sender/dingtalk.go b/alert/sender/dingtalk.go
similarity index 84%
rename from src/server/common/sender/dingtalk.go
rename to alert/sender/dingtalk.go
index ccd60bd9f2cad04af43a06e7d9453ef865ae028d..694a902131241a2ad7ca71c8d8186054b82a3a2a 100644
--- a/src/server/common/sender/dingtalk.go
+++ b/alert/sender/dingtalk.go
@@ -5,10 +5,10 @@ import (
"strings"
"time"
- "github.com/toolkits/pkg/logger"
+ "github.com/ccfos/nightingale/v6/models"
+ "github.com/ccfos/nightingale/v6/pkg/poster"
- "github.com/didi/nightingale/v5/src/models"
- "github.com/didi/nightingale/v5/src/pkg/poster"
+ "github.com/toolkits/pkg/logger"
)
type dingtalkMarkdown struct {
@@ -70,23 +70,6 @@ func (ds *DingtalkSender) Send(ctx MessageContext) {
}
}
-func (ds *DingtalkSender) SendRaw(users []*models.User, title, message string) {
- if len(users) == 0 {
- return
- }
- urls, _ := ds.extract(users)
- body := dingtalk{
- Msgtype: "markdown",
- Markdown: dingtalkMarkdown{
- Title: title,
- Text: message,
- },
- }
- for _, url := range urls {
- ds.doSend(url, body)
- }
-}
-
// extract urls and ats from Users
func (ds *DingtalkSender) extract(users []*models.User) ([]string, []string) {
urls := make([]string, 0, len(users))
diff --git a/src/server/common/sender/email.go b/alert/sender/email.go
similarity index 82%
rename from src/server/common/sender/email.go
rename to alert/sender/email.go
index 7e8465906c03ab7e51a10ba29ff22eceffd364db..67606d4c3eb7129b9bbaa1a4ba8090a283d25e54 100644
--- a/src/server/common/sender/email.go
+++ b/alert/sender/email.go
@@ -5,11 +5,12 @@ import (
"html/template"
"time"
+ "github.com/ccfos/nightingale/v6/alert/aconf"
+ "github.com/ccfos/nightingale/v6/models"
+
"github.com/toolkits/pkg/logger"
- "gopkg.in/gomail.v2"
- "github.com/didi/nightingale/v5/src/models"
- "github.com/didi/nightingale/v5/src/server/config"
+ "gopkg.in/gomail.v2"
)
var mailch chan *gomail.Message
@@ -17,13 +18,14 @@ var mailch chan *gomail.Message
type EmailSender struct {
subjectTpl *template.Template
contentTpl *template.Template
+ smtp aconf.SMTPConfig
}
func (es *EmailSender) Send(ctx MessageContext) {
if len(ctx.Users) == 0 || ctx.Rule == nil || ctx.Event == nil {
return
}
- tos := es.extract(ctx.Users)
+ tos := extract(ctx.Users)
var subject string
if es.subjectTpl != nil {
@@ -32,15 +34,10 @@ func (es *EmailSender) Send(ctx MessageContext) {
subject = ctx.Rule.Name
}
content := BuildTplMessage(es.contentTpl, ctx.Event)
- WriteEmail(subject, content, tos)
-}
-
-func (es *EmailSender) SendRaw(users []*models.User, title, message string) {
- tos := es.extract(users)
- WriteEmail(title, message, tos)
+ es.WriteEmail(subject, content, tos)
}
-func (es *EmailSender) extract(users []*models.User) []string {
+func extract(users []*models.User) []string {
tos := make([]string, 0, len(users))
for _, u := range users {
if u.Email != "" {
@@ -50,8 +47,8 @@ func (es *EmailSender) extract(users []*models.User) []string {
return tos
}
-func SendEmail(subject, content string, tos []string) {
- conf := config.C.SMTP
+func (es *EmailSender) SendEmail(subject, content string, tos []string, stmp aconf.SMTPConfig) {
+ conf := stmp
d := gomail.NewDialer(conf.Host, conf.Port, conf.User, conf.Pass)
if conf.InsecureSkipVerify {
@@ -60,7 +57,7 @@ func SendEmail(subject, content string, tos []string) {
m := gomail.NewMessage()
- m.SetHeader("From", config.C.SMTP.From)
+ m.SetHeader("From", stmp.From)
m.SetHeader("To", tos...)
m.SetHeader("Subject", subject)
m.SetBody("text/html", content)
@@ -71,10 +68,10 @@ func SendEmail(subject, content string, tos []string) {
}
}
-func WriteEmail(subject, content string, tos []string) {
+func (es *EmailSender) WriteEmail(subject, content string, tos []string) {
m := gomail.NewMessage()
- m.SetHeader("From", config.C.SMTP.From)
+ m.SetHeader("From", es.smtp.From)
m.SetHeader("To", tos...)
m.SetHeader("Subject", subject)
m.SetBody("text/html", content)
@@ -94,10 +91,10 @@ func dialSmtp(d *gomail.Dialer) gomail.SendCloser {
}
}
-func StartEmailSender() {
+func StartEmailSender(smtp aconf.SMTPConfig) {
mailch = make(chan *gomail.Message, 100000)
- conf := config.C.SMTP
+ conf := smtp
if conf.Host == "" || conf.Port == 0 {
logger.Warning("SMTP configurations invalid")
diff --git a/src/server/common/sender/feishu.go b/alert/sender/feishu.go
similarity index 82%
rename from src/server/common/sender/feishu.go
rename to alert/sender/feishu.go
index 3d994885078efd90db5b44e9ba412b266c7bed95..bf03176dfcde8e53c8e47ad65546061fd499753a 100644
--- a/src/server/common/sender/feishu.go
+++ b/alert/sender/feishu.go
@@ -5,10 +5,10 @@ import (
"strings"
"time"
- "github.com/toolkits/pkg/logger"
+ "github.com/ccfos/nightingale/v6/models"
+ "github.com/ccfos/nightingale/v6/pkg/poster"
- "github.com/didi/nightingale/v5/src/models"
- "github.com/didi/nightingale/v5/src/pkg/poster"
+ "github.com/toolkits/pkg/logger"
)
type feishuContent struct {
@@ -53,22 +53,6 @@ func (fs *FeishuSender) Send(ctx MessageContext) {
}
}
-func (fs *FeishuSender) SendRaw(users []*models.User, title, message string) {
- if len(users) == 0 {
- return
- }
- urls, _ := fs.extract(users)
- body := feishu{
- Msgtype: "text",
- Content: feishuContent{
- Text: message,
- },
- }
- for _, url := range urls {
- fs.doSend(url, body)
- }
-}
-
func (fs *FeishuSender) extract(users []*models.User) ([]string, []string) {
urls := make([]string, 0, len(users))
ats := make([]string, 0, len(users))
diff --git a/src/server/common/sender/mm.go b/alert/sender/mm.go
similarity index 88%
rename from src/server/common/sender/mm.go
rename to alert/sender/mm.go
index 3fc94c8396e619dfd5345d6638555efaa8f4d4c9..d61ecc15f0652a90d68711817a881df33a7fe549 100644
--- a/src/server/common/sender/mm.go
+++ b/alert/sender/mm.go
@@ -6,10 +6,10 @@ import (
"strings"
"time"
- "github.com/toolkits/pkg/logger"
+ "github.com/ccfos/nightingale/v6/models"
+ "github.com/ccfos/nightingale/v6/pkg/poster"
- "github.com/didi/nightingale/v5/src/models"
- "github.com/didi/nightingale/v5/src/pkg/poster"
+ "github.com/toolkits/pkg/logger"
)
type MatterMostMessage struct {
@@ -44,17 +44,6 @@ func (ms *MmSender) Send(ctx MessageContext) {
})
}
-func (ms *MmSender) SendRaw(users []*models.User, title, message string) {
- urls := ms.extract(users)
- if len(urls) == 0 {
- return
- }
- SendMM(MatterMostMessage{
- Text: message,
- Tokens: urls,
- })
-}
-
func (ms *MmSender) extract(users []*models.User) []string {
tokens := make([]string, 0, len(users))
for _, user := range users {
diff --git a/alert/sender/plugin.go b/alert/sender/plugin.go
new file mode 100644
index 0000000000000000000000000000000000000000..d3e51208918a1c87de46296e6c83bf7962a4f0ac
--- /dev/null
+++ b/alert/sender/plugin.go
@@ -0,0 +1,97 @@
+package sender
+
+import (
+ "bytes"
+ "os"
+ "os/exec"
+ "time"
+
+ "github.com/ccfos/nightingale/v6/memsto"
+
+ "github.com/toolkits/pkg/file"
+ "github.com/toolkits/pkg/logger"
+ "github.com/toolkits/pkg/sys"
+)
+
+func MayPluginNotify(noticeBytes []byte, notifyScript *memsto.NotifyScriptCacheType) {
+ if len(noticeBytes) == 0 {
+ return
+ }
+ alertingCallScript(noticeBytes, notifyScript)
+}
+
+func alertingCallScript(stdinBytes []byte, notifyScript *memsto.NotifyScriptCacheType) {
+ // not enable or no notify.py? do nothing
+ config := notifyScript.GetNotifyScript()
+ if !config.Enable || config.Content == "" {
+ return
+ }
+
+ fpath := ".notify_scriptt"
+ if config.Type == 1 {
+ fpath = config.Content
+ } else {
+ rewrite := true
+ if file.IsExist(fpath) {
+ oldContent, err := file.ToString(fpath)
+ if err != nil {
+ logger.Errorf("event_notify: read script file err: %v", err)
+ return
+ }
+
+ if oldContent == config.Content {
+ rewrite = false
+ }
+ }
+
+ if rewrite {
+ _, err := file.WriteString(fpath, config.Content)
+ if err != nil {
+ logger.Errorf("event_notify: write script file err: %v", err)
+ return
+ }
+
+ err = os.Chmod(fpath, 0777)
+ if err != nil {
+ logger.Errorf("event_notify: chmod script file err: %v", err)
+ return
+ }
+ }
+ fpath = "./" + fpath
+ }
+
+ cmd := exec.Command(fpath)
+ cmd.Stdin = bytes.NewReader(stdinBytes)
+
+ // combine stdout and stderr
+ var buf bytes.Buffer
+ cmd.Stdout = &buf
+ cmd.Stderr = &buf
+
+ err := startCmd(cmd)
+ if err != nil {
+ logger.Errorf("event_notify: run cmd err: %v", err)
+ return
+ }
+
+ err, isTimeout := sys.WrapTimeout(cmd, time.Duration(config.Timeout)*time.Second)
+
+ if isTimeout {
+ if err == nil {
+ logger.Errorf("event_notify: timeout and killed process %s", fpath)
+ }
+
+ if err != nil {
+ logger.Errorf("event_notify: kill process %s occur error %v", fpath, err)
+ }
+
+ return
+ }
+
+ if err != nil {
+ logger.Errorf("event_notify: exec script %s occur error: %v, output: %s", fpath, err, buf.String())
+ return
+ }
+
+ logger.Infof("event_notify: exec %s output: %s", fpath, buf.String())
+}
diff --git a/src/server/common/sender/plugin_cmd_unix.go b/alert/sender/plugin_cmd_unix.go
similarity index 100%
rename from src/server/common/sender/plugin_cmd_unix.go
rename to alert/sender/plugin_cmd_unix.go
diff --git a/src/server/common/sender/plugin_cmd_windows.go b/alert/sender/plugin_cmd_windows.go
similarity index 100%
rename from src/server/common/sender/plugin_cmd_windows.go
rename to alert/sender/plugin_cmd_windows.go
diff --git a/src/server/common/sender/sender.go b/alert/sender/sender.go
similarity index 54%
rename from src/server/common/sender/sender.go
rename to alert/sender/sender.go
index e1d5c28ea7e2b6f17f3123b5c5cab7ac6f4d2bdc..a78adf9c2ed9d049b3a296511b2c36a7a8fb5bfc 100644
--- a/src/server/common/sender/sender.go
+++ b/alert/sender/sender.go
@@ -4,20 +4,14 @@ import (
"bytes"
"html/template"
- "github.com/toolkits/pkg/slice"
-
- "github.com/didi/nightingale/v5/src/models"
- "github.com/didi/nightingale/v5/src/server/config"
- "github.com/didi/nightingale/v5/src/server/memsto"
+ "github.com/ccfos/nightingale/v6/memsto"
+ "github.com/ccfos/nightingale/v6/models"
)
type (
// Sender 发送消息通知的接口
Sender interface {
Send(ctx MessageContext)
-
- // SendRaw 发送原始消息,目前在notifyMaintainer时使用
- SendRaw(users []*models.User, title, message string)
}
// MessageContext 一个event所生成的告警通知的上下文
@@ -29,29 +23,25 @@ type (
)
func NewSender(key string, tpls map[string]*template.Template) Sender {
- if !slice.ContainsString(config.C.Alerting.NotifyBuiltinChannels, key) {
- return nil
- }
-
switch key {
case models.Dingtalk:
- return &DingtalkSender{tpl: tpls["dingtalk.tpl"]}
+ return &DingtalkSender{tpl: tpls[models.Dingtalk]}
case models.Wecom:
- return &WecomSender{tpl: tpls["wecom.tpl"]}
+ return &WecomSender{tpl: tpls[models.Wecom]}
case models.Feishu:
- return &FeishuSender{tpl: tpls["feishu.tpl"]}
+ return &FeishuSender{tpl: tpls[models.Feishu]}
case models.Email:
- return &EmailSender{subjectTpl: tpls["subject.tpl"], contentTpl: tpls["mailbody.tpl"]}
+ return &EmailSender{subjectTpl: tpls["mailsubject"], contentTpl: tpls[models.Email]}
case models.Mm:
- return &MmSender{tpl: tpls["mm.tpl"]}
+ return &MmSender{tpl: tpls[models.Mm]}
case models.Telegram:
- return &TelegramSender{tpl: tpls["telegram.tpl"]}
+ return &TelegramSender{tpl: tpls[models.Telegram]}
}
return nil
}
-func BuildMessageContext(rule *models.AlertRule, event *models.AlertCurEvent, uids []int64) MessageContext {
- users := memsto.UserCache.GetByUserIds(uids)
+func BuildMessageContext(rule *models.AlertRule, event *models.AlertCurEvent, uids []int64, userCache *memsto.UserCacheType) MessageContext {
+ users := userCache.GetByUserIds(uids)
return MessageContext{
Rule: rule,
Event: event,
diff --git a/src/server/common/sender/telegram.go b/alert/sender/telegram.go
similarity index 87%
rename from src/server/common/sender/telegram.go
rename to alert/sender/telegram.go
index 8d7aee4dddfc9d70f3f03110e25b61c7975bfccd..75ded37ad11342d383015cac17b5d3087848a906 100644
--- a/src/server/common/sender/telegram.go
+++ b/alert/sender/telegram.go
@@ -5,10 +5,10 @@ import (
"strings"
"time"
- "github.com/toolkits/pkg/logger"
+ "github.com/ccfos/nightingale/v6/models"
+ "github.com/ccfos/nightingale/v6/pkg/poster"
- "github.com/didi/nightingale/v5/src/models"
- "github.com/didi/nightingale/v5/src/pkg/poster"
+ "github.com/toolkits/pkg/logger"
)
type TelegramMessage struct {
@@ -38,14 +38,6 @@ func (ts *TelegramSender) Send(ctx MessageContext) {
})
}
-func (ts *TelegramSender) SendRaw(users []*models.User, title, message string) {
- tokens := ts.extract(users)
- SendTelegram(TelegramMessage{
- Text: message,
- Tokens: tokens,
- })
-}
-
func (ts *TelegramSender) extract(users []*models.User) []string {
tokens := make([]string, 0, len(users))
for _, user := range users {
diff --git a/src/server/common/sender/webhook.go b/alert/sender/webhook.go
similarity index 86%
rename from src/server/common/sender/webhook.go
rename to alert/sender/webhook.go
index 43e64b572a52d3315e010c0df26c092d9f6769ac..c8fb552b8278fdede2ee265496d475820cc2d8be 100644
--- a/src/server/common/sender/webhook.go
+++ b/alert/sender/webhook.go
@@ -5,14 +5,14 @@ import (
"encoding/json"
"io/ioutil"
"net/http"
+ "time"
- "github.com/toolkits/pkg/logger"
+ "github.com/ccfos/nightingale/v6/models"
- "github.com/didi/nightingale/v5/src/models"
- "github.com/didi/nightingale/v5/src/server/config"
+ "github.com/toolkits/pkg/logger"
)
-func SendWebhooks(webhooks []config.Webhook, event *models.AlertCurEvent) {
+func SendWebhooks(webhooks []*models.Webhook, event *models.AlertCurEvent) {
for _, conf := range webhooks {
if conf.Url == "" || !conf.Enable {
continue
@@ -44,8 +44,9 @@ func SendWebhooks(webhooks []config.Webhook, event *models.AlertCurEvent) {
}
}
+ // todo add skip verify
client := http.Client{
- Timeout: conf.TimeoutDuration,
+ Timeout: time.Duration(conf.Timeout) * time.Second,
}
var resp *http.Response
diff --git a/src/server/common/sender/wecom.go b/alert/sender/wecom.go
similarity index 79%
rename from src/server/common/sender/wecom.go
rename to alert/sender/wecom.go
index 3ed58a287e7e892fa81b341df33ba3e87076b5c7..6044eff8786959fe37fcbac413dc17b236258ffe 100644
--- a/src/server/common/sender/wecom.go
+++ b/alert/sender/wecom.go
@@ -5,10 +5,10 @@ import (
"strings"
"time"
- "github.com/toolkits/pkg/logger"
+ "github.com/ccfos/nightingale/v6/models"
+ "github.com/ccfos/nightingale/v6/pkg/poster"
- "github.com/didi/nightingale/v5/src/models"
- "github.com/didi/nightingale/v5/src/pkg/poster"
+ "github.com/toolkits/pkg/logger"
)
type wecomMarkdown struct {
@@ -41,19 +41,6 @@ func (ws *WecomSender) Send(ctx MessageContext) {
}
}
-func (ws *WecomSender) SendRaw(users []*models.User, title, message string) {
- urls := ws.extract(users)
- for _, url := range urls {
- body := wecom{
- Msgtype: "markdown",
- Markdown: wecomMarkdown{
- Content: message,
- },
- }
- ws.doSend(url, body)
- }
-}
-
func (ws *WecomSender) extract(users []*models.User) []string {
urls := make([]string, 0, len(users))
for _, user := range users {
diff --git a/center/cconf/conf.go b/center/cconf/conf.go
new file mode 100644
index 0000000000000000000000000000000000000000..b71c67bf605a8adb2932dd177c98e2af4bc6cc18
--- /dev/null
+++ b/center/cconf/conf.go
@@ -0,0 +1,67 @@
+package cconf
+
+import (
+ "github.com/ccfos/nightingale/v6/pkg/cas"
+ "github.com/ccfos/nightingale/v6/pkg/ldapx"
+ "github.com/ccfos/nightingale/v6/pkg/oauth2x"
+ "github.com/ccfos/nightingale/v6/pkg/oidcx"
+
+ "github.com/gin-gonic/gin"
+)
+
+type Center struct {
+ Plugins []Plugin
+ BasicAuth gin.Accounts
+ MetricsYamlFile string
+ OpsYamlFile string
+ BuiltinIntegrationsDir string
+ I18NHeaderKey string
+ MetricDesc MetricDescType
+ TargetMetrics map[string]string
+ AnonymousAccess AnonymousAccess
+ JWTAuth JWTAuth
+ ProxyAuth ProxyAuth
+ LDAP ldapx.Config
+ OIDC oidcx.Config
+ CAS cas.Config
+ OAuth oauth2x.Config
+ Ibex Ibex
+}
+
+type Plugin struct {
+ Id int64 `json:"id"`
+ Category string `json:"category"`
+ Type string `json:"plugin_type"`
+ TypeName string `json:"plugin_type_name"`
+}
+
+type ProxyAuth struct {
+ Enable bool
+ HeaderUserNameKey string
+ DefaultRoles []string
+}
+
+type JWTAuth struct {
+ SigningKey string
+ AccessExpired int64
+ RefreshExpired int64
+ RedisKeyPrefix string
+}
+
+type AnonymousAccess struct {
+ PromQuerier bool
+ AlertDetail bool
+}
+
+type Ibex struct {
+ Address string
+ BasicAuthUser string
+ BasicAuthPass string
+ Timeout int64
+}
+
+func (c *Center) PreCheck() {
+ if len(c.Plugins) == 0 {
+ c.Plugins = Plugins
+ }
+}
diff --git a/src/webapi/config/metrics.go b/center/cconf/metric.go
similarity index 85%
rename from src/webapi/config/metrics.go
rename to center/cconf/metric.go
index cf18fbb14e8ac47194b7e8578d6f4c4859a9f117..a8b12f8544e0574936c22d4c53197ffd20a85377 100644
--- a/src/webapi/config/metrics.go
+++ b/center/cconf/metric.go
@@ -1,4 +1,4 @@
-package config
+package cconf
import (
"path"
@@ -8,13 +8,13 @@ import (
)
// metricDesc , As load map happens before read map, there is no necessary to use concurrent map for metric desc store
-type metricDesc struct {
+type MetricDescType struct {
CommonDesc map[string]string `yaml:",inline" json:"common"`
Zh map[string]string `yaml:"zh" json:"zh"`
En map[string]string `yaml:"en" json:"en"`
}
-var MetricDesc metricDesc
+var MetricDesc MetricDescType
// GetMetricDesc , if metric is not registered, empty string will be returned
func GetMetricDesc(lang, metric string) string {
@@ -33,8 +33,8 @@ func GetMetricDesc(lang, metric string) string {
return MetricDesc.CommonDesc[metric]
}
-func loadMetricsYaml() error {
- fp := C.MetricsYamlFile
+func LoadMetricsYaml(metricsYamlFile string) error {
+ fp := metricsYamlFile
if fp == "" {
fp = path.Join(runner.Cwd, "etc", "metrics.yaml")
}
diff --git a/center/cconf/ops.go b/center/cconf/ops.go
new file mode 100644
index 0000000000000000000000000000000000000000..4489a64e745e78c7ab6e29581f5b88961bdbe9ea
--- /dev/null
+++ b/center/cconf/ops.go
@@ -0,0 +1,39 @@
+package cconf
+
+import (
+ "path"
+
+ "github.com/toolkits/pkg/file"
+ "github.com/toolkits/pkg/runner"
+)
+
+var Operations = Operation{}
+
+type Operation struct {
+ Ops []Ops `yaml:"ops"`
+}
+
+type Ops struct {
+ Name string `yaml:"name" json:"name"`
+ Cname string `yaml:"cname" json:"cname"`
+ Ops []string `yaml:"ops" json:"ops"`
+}
+
+func LoadOpsYaml(opsYamlFile string) error {
+ fp := opsYamlFile
+ if fp == "" {
+ fp = path.Join(runner.Cwd, "etc", "ops.yaml")
+ }
+ if !file.IsExist(fp) {
+ return nil
+ }
+ return file.ReadYaml(fp, &Operations)
+}
+
+func GetAllOps(ops []Ops) []string {
+ var ret []string
+ for _, op := range ops {
+ ret = append(ret, op.Ops...)
+ }
+ return ret
+}
diff --git a/center/cconf/plugin.go b/center/cconf/plugin.go
new file mode 100644
index 0000000000000000000000000000000000000000..3a37f7829f16ebf69f93cd90b0dcb3dea9f7ab5a
--- /dev/null
+++ b/center/cconf/plugin.go
@@ -0,0 +1,22 @@
+package cconf
+
+var Plugins = []Plugin{
+ {
+ Id: 1,
+ Category: "timeseries",
+ Type: "prometheus",
+ TypeName: "Prometheus Like",
+ },
+ {
+ Id: 2,
+ Category: "logging",
+ Type: "elasticsearch",
+ TypeName: "Elasticsearch",
+ },
+ {
+ Id: 3,
+ Category: "logging",
+ Type: "jaeger",
+ TypeName: "Jaeger",
+ },
+}
diff --git a/center/center.go b/center/center.go
new file mode 100644
index 0000000000000000000000000000000000000000..76ff257f1f5cb41a2b43add0b542dad5da4a6e13
--- /dev/null
+++ b/center/center.go
@@ -0,0 +1,92 @@
+package center
+
+import (
+ "context"
+ "fmt"
+
+ "github.com/ccfos/nightingale/v6/alert"
+ "github.com/ccfos/nightingale/v6/alert/astats"
+ "github.com/ccfos/nightingale/v6/alert/process"
+ "github.com/ccfos/nightingale/v6/center/cconf"
+ "github.com/ccfos/nightingale/v6/center/sso"
+ "github.com/ccfos/nightingale/v6/conf"
+ "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/httpx"
+ "github.com/ccfos/nightingale/v6/pkg/logx"
+ "github.com/ccfos/nightingale/v6/prom"
+ "github.com/ccfos/nightingale/v6/pushgw/idents"
+ "github.com/ccfos/nightingale/v6/pushgw/writer"
+ "github.com/ccfos/nightingale/v6/storage"
+
+ alertrt "github.com/ccfos/nightingale/v6/alert/router"
+ centerrt "github.com/ccfos/nightingale/v6/center/router"
+ pushgwrt "github.com/ccfos/nightingale/v6/pushgw/router"
+
+ "github.com/toolkits/pkg/i18n"
+)
+
+func Initialize(configDir string, cryptoKey string) (func(), error) {
+ config, err := conf.InitConfig(configDir, cryptoKey)
+ if err != nil {
+ return nil, fmt.Errorf("failed to init config: %v", err)
+ }
+
+ cconf.LoadMetricsYaml(config.Center.MetricsYamlFile)
+ cconf.LoadOpsYaml(config.Center.OpsYamlFile)
+
+ logxClean, err := logx.Init(config.Log)
+ if err != nil {
+ return nil, err
+ }
+
+ i18n.Init()
+
+ db, err := storage.New(config.DB)
+ if err != nil {
+ return nil, err
+ }
+ ctx := ctx.NewContext(context.Background(), db)
+ models.InitRoot(ctx)
+
+ redis, err := storage.NewRedis(config.Redis)
+ if err != nil {
+ return nil, err
+ }
+
+ syncStats := memsto.NewSyncStats()
+ alertStats := astats.NewSyncStats()
+ idents := idents.New(db, config.Pushgw.DatasourceId, config.Pushgw.MaxOffset)
+ sso := sso.Init(config.Center, ctx)
+
+ busiGroupCache := memsto.NewBusiGroupCache(ctx, syncStats)
+ targetCache := memsto.NewTargetCache(ctx, syncStats)
+ dsCache := memsto.NewDatasourceCache(ctx, syncStats)
+ alertMuteCache := memsto.NewAlertMuteCache(ctx, syncStats)
+ alertRuleCache := memsto.NewAlertRuleCache(ctx, syncStats)
+
+ promClients := prom.NewPromClient(ctx, config.Alert.Heartbeat)
+
+ externalProcessors := process.NewExternalProcessors()
+ alert.Start(config.Alert, config.Pushgw, syncStats, alertStats, externalProcessors, targetCache, busiGroupCache, alertMuteCache, alertRuleCache, ctx, promClients)
+
+ writers := writer.NewWriters(config.Pushgw)
+
+ alertrtRouter := alertrt.New(config.HTTP, config.Alert, alertMuteCache, targetCache, busiGroupCache, alertStats, ctx, externalProcessors)
+ centerRouter := centerrt.New(config.HTTP, config.Center, cconf.Operations, dsCache, promClients, redis, sso, ctx)
+ pushgwRouter := pushgwrt.New(config.HTTP, config.Pushgw, targetCache, busiGroupCache, idents, writers, ctx)
+
+ r := httpx.GinEngine(config.Global.RunMode, config.HTTP)
+
+ centerRouter.Config(r)
+ alertrtRouter.Config(r)
+ pushgwRouter.Config(r)
+
+ httpClean := httpx.Init(config.HTTP, r)
+
+ return func() {
+ logxClean()
+ httpClean()
+ }, nil
+}
diff --git a/src/webapi/stat/stat.go b/center/cstats/stats.go
similarity index 95%
rename from src/webapi/stat/stat.go
rename to center/cstats/stats.go
index 52d539c6ecb876f8df78e86114277dcd7d7e61ff..07e3705112785400b234d21a54d22d09f54b7285 100644
--- a/src/webapi/stat/stat.go
+++ b/center/cstats/stats.go
@@ -1,4 +1,4 @@
-package stat
+package cstats
import (
"time"
@@ -6,7 +6,7 @@ import (
"github.com/prometheus/client_golang/prometheus"
)
-const Service = "n9e-webapi"
+const Service = "n9e-center"
var (
labels = []string{"service", "code", "path", "method"}
diff --git a/center/router/router.go b/center/router/router.go
new file mode 100644
index 0000000000000000000000000000000000000000..b553c8a074bd601f18dc163efc234aad312f36fe
--- /dev/null
+++ b/center/router/router.go
@@ -0,0 +1,374 @@
+package router
+
+import (
+ "fmt"
+ "net/http"
+ "path"
+ "strings"
+ "time"
+
+ "github.com/ccfos/nightingale/v6/center/cconf"
+ "github.com/ccfos/nightingale/v6/center/cstats"
+ "github.com/ccfos/nightingale/v6/center/sso"
+ "github.com/ccfos/nightingale/v6/memsto"
+ "github.com/ccfos/nightingale/v6/pkg/aop"
+ "github.com/ccfos/nightingale/v6/pkg/ctx"
+ "github.com/ccfos/nightingale/v6/pkg/httpx"
+ "github.com/ccfos/nightingale/v6/prom"
+ "github.com/ccfos/nightingale/v6/storage"
+ "github.com/toolkits/pkg/ginx"
+
+ "github.com/gin-gonic/gin"
+)
+
+type Router struct {
+ HTTP httpx.Config
+ Center cconf.Center
+ Operations cconf.Operation
+ DatasourceCache *memsto.DatasourceCacheType
+ PromClients *prom.PromClientMap
+ Redis storage.Redis
+ Sso *sso.SsoClient
+ Ctx *ctx.Context
+}
+
+func New(httpConfig httpx.Config, center cconf.Center, operations cconf.Operation, ds *memsto.DatasourceCacheType, pc *prom.PromClientMap,
+ redis storage.Redis, sso *sso.SsoClient, ctx *ctx.Context) *Router {
+ return &Router{
+ HTTP: httpConfig,
+ Center: center,
+ Operations: operations,
+ DatasourceCache: ds,
+ PromClients: pc,
+ Redis: redis,
+ Sso: sso,
+ Ctx: ctx,
+ }
+}
+
+func stat() gin.HandlerFunc {
+ return func(c *gin.Context) {
+ start := time.Now()
+ c.Next()
+
+ code := fmt.Sprintf("%d", c.Writer.Status())
+ method := c.Request.Method
+ labels := []string{cstats.Service, code, c.FullPath(), method}
+
+ cstats.RequestCounter.WithLabelValues(labels...).Inc()
+ cstats.RequestDuration.WithLabelValues(labels...).Observe(float64(time.Since(start).Seconds()))
+ }
+}
+
+func languageDetector(i18NHeaderKey string) gin.HandlerFunc {
+ headerKey := i18NHeaderKey
+ return func(c *gin.Context) {
+ if headerKey != "" {
+ lang := c.GetHeader(headerKey)
+ if lang != "" {
+ if strings.HasPrefix(lang, "zh") {
+ c.Request.Header.Set("X-Language", "zh")
+ } else if strings.HasPrefix(lang, "en") {
+ c.Request.Header.Set("X-Language", "en")
+ } else {
+ c.Request.Header.Set("X-Language", lang)
+ }
+ } else {
+ c.Request.Header.Set("X-Language", "en")
+ }
+ }
+ c.Next()
+ }
+}
+
+func (rt *Router) configNoRoute(r *gin.Engine) {
+ r.NoRoute(func(c *gin.Context) {
+ arr := strings.Split(c.Request.URL.Path, ".")
+ suffix := arr[len(arr)-1]
+ switch suffix {
+ case "png", "jpeg", "jpg", "svg", "ico", "gif", "css", "js", "html", "htm", "gz", "zip", "map":
+ c.File(path.Join(strings.Split("pub/"+c.Request.URL.Path, "/")...))
+ default:
+ c.File(path.Join("pub", "index.html"))
+ }
+ })
+}
+
+func (rt *Router) Config(r *gin.Engine) {
+ r.Use(stat())
+ r.Use(languageDetector(rt.Center.I18NHeaderKey))
+ r.Use(aop.Recovery())
+
+ pagesPrefix := "/api/n9e"
+ pages := r.Group(pagesPrefix)
+ {
+
+ if rt.Center.AnonymousAccess.PromQuerier {
+ pages.Any("/proxy/:id/*url", rt.dsProxy)
+ pages.POST("/query-range-batch", rt.promBatchQueryRange)
+ } else {
+ pages.Any("/proxy/:id/*url", rt.auth(), rt.dsProxy)
+ pages.POST("/query-range-batch", rt.auth(), rt.promBatchQueryRange)
+ }
+
+ pages.POST("/auth/login", rt.jwtMock(), rt.loginPost)
+ pages.POST("/auth/logout", rt.jwtMock(), rt.logoutPost)
+ pages.POST("/auth/refresh", rt.jwtMock(), rt.refreshPost)
+
+ pages.GET("/auth/sso-config", rt.ssoConfigNameGet)
+ pages.GET("/auth/redirect", rt.loginRedirect)
+ pages.GET("/auth/redirect/cas", rt.loginRedirectCas)
+ pages.GET("/auth/redirect/oauth", rt.loginRedirectOAuth)
+ pages.GET("/auth/callback", rt.loginCallback)
+ pages.GET("/auth/callback/cas", rt.loginCallbackCas)
+ pages.GET("/auth/callback/oauth", rt.loginCallbackOAuth)
+
+ pages.GET("/metrics/desc", rt.metricsDescGetFile)
+ pages.POST("/metrics/desc", rt.metricsDescGetMap)
+
+ pages.GET("/notify-channels", rt.notifyChannelsGets)
+ pages.GET("/contact-keys", rt.contactKeysGets)
+
+ pages.GET("/self/perms", rt.auth(), rt.user(), rt.permsGets)
+ pages.GET("/self/profile", rt.auth(), rt.user(), rt.selfProfileGet)
+ pages.PUT("/self/profile", rt.auth(), rt.user(), rt.selfProfilePut)
+ pages.PUT("/self/password", rt.auth(), rt.user(), rt.selfPasswordPut)
+
+ pages.GET("/users", rt.auth(), rt.user(), rt.perm("/users"), rt.userGets)
+ pages.POST("/users", rt.auth(), rt.admin(), rt.userAddPost)
+ pages.GET("/user/:id/profile", rt.auth(), rt.userProfileGet)
+ pages.PUT("/user/:id/profile", rt.auth(), rt.admin(), rt.userProfilePut)
+ pages.PUT("/user/:id/password", rt.auth(), rt.admin(), rt.userPasswordPut)
+ pages.DELETE("/user/:id", rt.auth(), rt.admin(), rt.userDel)
+
+ pages.GET("/metric-views", rt.auth(), rt.metricViewGets)
+ pages.DELETE("/metric-views", rt.auth(), rt.user(), rt.metricViewDel)
+ pages.POST("/metric-views", rt.auth(), rt.user(), rt.metricViewAdd)
+ pages.PUT("/metric-views", rt.auth(), rt.user(), rt.metricViewPut)
+
+ pages.GET("/user-groups", rt.auth(), rt.user(), rt.userGroupGets)
+ pages.POST("/user-groups", rt.auth(), rt.user(), rt.perm("/user-groups/add"), rt.userGroupAdd)
+ pages.GET("/user-group/:id", rt.auth(), rt.user(), rt.userGroupGet)
+ pages.PUT("/user-group/:id", rt.auth(), rt.user(), rt.perm("/user-groups/put"), rt.userGroupWrite(), rt.userGroupPut)
+ pages.DELETE("/user-group/:id", rt.auth(), rt.user(), rt.perm("/user-groups/del"), rt.userGroupWrite(), rt.userGroupDel)
+ pages.POST("/user-group/:id/members", rt.auth(), rt.user(), rt.perm("/user-groups/put"), rt.userGroupWrite(), rt.userGroupMemberAdd)
+ pages.DELETE("/user-group/:id/members", rt.auth(), rt.user(), rt.perm("/user-groups/put"), rt.userGroupWrite(), rt.userGroupMemberDel)
+
+ pages.GET("/busi-groups", rt.auth(), rt.user(), rt.busiGroupGets)
+ pages.POST("/busi-groups", rt.auth(), rt.user(), rt.perm("/busi-groups/add"), rt.busiGroupAdd)
+ pages.GET("/busi-groups/alertings", rt.auth(), rt.busiGroupAlertingsGets)
+ pages.GET("/busi-group/:id", rt.auth(), rt.user(), rt.bgro(), rt.busiGroupGet)
+ pages.PUT("/busi-group/:id", rt.auth(), rt.user(), rt.perm("/busi-groups/put"), rt.bgrw(), rt.busiGroupPut)
+ pages.POST("/busi-group/:id/members", rt.auth(), rt.user(), rt.perm("/busi-groups/put"), rt.bgrw(), rt.busiGroupMemberAdd)
+ pages.DELETE("/busi-group/:id/members", rt.auth(), rt.user(), rt.perm("/busi-groups/put"), rt.bgrw(), rt.busiGroupMemberDel)
+ pages.DELETE("/busi-group/:id", rt.auth(), rt.user(), rt.perm("/busi-groups/del"), rt.bgrw(), rt.busiGroupDel)
+ pages.GET("/busi-group/:id/perm/:perm", rt.auth(), rt.user(), rt.checkBusiGroupPerm)
+
+ pages.GET("/targets", rt.auth(), rt.user(), rt.targetGets)
+ pages.POST("/target/list", rt.auth(), rt.user(), rt.targetGetsByHostFilter)
+ pages.DELETE("/targets", rt.auth(), rt.user(), rt.perm("/targets/del"), rt.targetDel)
+ pages.GET("/targets/tags", rt.auth(), rt.user(), rt.targetGetTags)
+ pages.POST("/targets/tags", rt.auth(), rt.user(), rt.perm("/targets/put"), rt.targetBindTagsByFE)
+ pages.DELETE("/targets/tags", rt.auth(), rt.user(), rt.perm("/targets/put"), rt.targetUnbindTagsByFE)
+ pages.PUT("/targets/note", rt.auth(), rt.user(), rt.perm("/targets/put"), rt.targetUpdateNote)
+ pages.PUT("/targets/bgid", rt.auth(), rt.user(), rt.perm("/targets/put"), rt.targetUpdateBgid)
+
+ pages.POST("/builtin-cate-favorite", rt.auth(), rt.user(), rt.builtinCateFavoriteAdd)
+ pages.DELETE("/builtin-cate-favorite/:name", rt.auth(), rt.user(), rt.builtinCateFavoriteDel)
+
+ pages.GET("/builtin-boards", rt.builtinBoardGets)
+ pages.GET("/builtin-board/:name", rt.builtinBoardGet)
+ pages.GET("/dashboards/builtin/list", rt.builtinBoardGets)
+ pages.GET("/builtin-boards-cates", rt.auth(), rt.user(), rt.builtinBoardCateGets)
+ pages.POST("/builtin-boards-detail", rt.auth(), rt.user(), rt.builtinBoardDetailGets)
+ pages.GET("/integrations/icon/:cate/:name", func(c *gin.Context) {
+ cate := ginx.UrlParamStr(c, "cate")
+ fp := "integrations/" + cate + "/icon/" + ginx.UrlParamStr(c, "name")
+ c.File(path.Join(fp))
+ })
+
+ pages.GET("/busi-group/:id/boards", rt.auth(), rt.user(), rt.perm("/dashboards"), rt.bgro(), rt.boardGets)
+ pages.POST("/busi-group/:id/boards", rt.auth(), rt.user(), rt.perm("/dashboards/add"), rt.bgrw(), rt.boardAdd)
+ pages.POST("/busi-group/:id/board/:bid/clone", rt.auth(), rt.user(), rt.perm("/dashboards/add"), rt.bgrw(), rt.boardClone)
+
+ pages.GET("/board/:bid", rt.boardGet)
+ pages.GET("/board/:bid/pure", rt.boardPureGet)
+ pages.PUT("/board/:bid", rt.auth(), rt.user(), rt.perm("/dashboards/put"), rt.boardPut)
+ pages.PUT("/board/:bid/configs", rt.auth(), rt.user(), rt.perm("/dashboards/put"), rt.boardPutConfigs)
+ pages.PUT("/board/:bid/public", rt.auth(), rt.user(), rt.perm("/dashboards/put"), rt.boardPutPublic)
+ pages.DELETE("/boards", rt.auth(), rt.user(), rt.perm("/dashboards/del"), rt.boardDel)
+
+ pages.GET("/share-charts", rt.chartShareGets)
+ pages.POST("/share-charts", rt.auth(), rt.chartShareAdd)
+
+ pages.GET("/alert-rules/builtin/list", rt.auth(), rt.user(), rt.alertRuleBuiltinList)
+ pages.GET("/alert-rules/builtin/alerts-cates", rt.auth(), rt.user(), rt.builtinAlertCateGets)
+
+ pages.POST("/busi-group/:id/alert-rules/builtin", rt.auth(), rt.user(), rt.perm("/alert-rules/add"), rt.bgrw(), rt.alertRuleBuiltinImport)
+ pages.GET("/busi-group/:id/alert-rules", rt.auth(), rt.user(), rt.perm("/alert-rules"), rt.alertRuleGets)
+ pages.POST("/busi-group/:id/alert-rules", rt.auth(), rt.user(), rt.perm("/alert-rules/add"), rt.bgrw(), rt.alertRuleAddByFE)
+ pages.DELETE("/busi-group/:id/alert-rules", rt.auth(), rt.user(), rt.perm("/alert-rules/del"), rt.bgrw(), rt.alertRuleDel)
+ pages.PUT("/busi-group/:id/alert-rules/fields", rt.auth(), rt.user(), rt.perm("/alert-rules/put"), rt.bgrw(), rt.alertRulePutFields)
+ pages.PUT("/busi-group/:id/alert-rule/:arid", rt.auth(), rt.user(), rt.perm("/alert-rules/put"), rt.alertRulePutByFE)
+ pages.GET("/alert-rule/:arid", rt.auth(), rt.user(), rt.perm("/alert-rules"), rt.alertRuleGet)
+
+ pages.GET("/busi-group/:id/recording-rules", rt.auth(), rt.user(), rt.perm("/recording-rules"), rt.recordingRuleGets)
+ pages.POST("/busi-group/:id/recording-rules", rt.auth(), rt.user(), rt.perm("/recording-rules/add"), rt.bgrw(), rt.recordingRuleAddByFE)
+ pages.DELETE("/busi-group/:id/recording-rules", rt.auth(), rt.user(), rt.perm("/recording-rules/del"), rt.bgrw(), rt.recordingRuleDel)
+ pages.PUT("/busi-group/:id/recording-rule/:rrid", rt.auth(), rt.user(), rt.perm("/recording-rules/put"), rt.bgrw(), rt.recordingRulePutByFE)
+ pages.GET("/recording-rule/:rrid", rt.auth(), rt.user(), rt.perm("/recording-rules"), rt.recordingRuleGet)
+ pages.PUT("/busi-group/:id/recording-rules/fields", rt.auth(), rt.user(), rt.perm("/recording-rules/put"), rt.recordingRulePutFields)
+
+ pages.GET("/busi-group/:id/alert-mutes", rt.auth(), rt.user(), rt.perm("/alert-mutes"), rt.bgro(), rt.alertMuteGetsByBG)
+ pages.POST("/busi-group/:id/alert-mutes", rt.auth(), rt.user(), rt.perm("/alert-mutes/add"), rt.bgrw(), rt.alertMuteAdd)
+ pages.DELETE("/busi-group/:id/alert-mutes", rt.auth(), rt.user(), rt.perm("/alert-mutes/del"), rt.bgrw(), rt.alertMuteDel)
+ pages.PUT("/busi-group/:id/alert-mute/:amid", rt.auth(), rt.user(), rt.perm("/alert-mutes/put"), rt.alertMutePutByFE)
+ pages.PUT("/busi-group/:id/alert-mutes/fields", rt.auth(), rt.user(), rt.perm("/alert-mutes/put"), rt.bgrw(), rt.alertMutePutFields)
+
+ pages.GET("/busi-group/:id/alert-subscribes", rt.auth(), rt.user(), rt.perm("/alert-subscribes"), rt.bgro(), rt.alertSubscribeGets)
+ pages.GET("/alert-subscribe/:sid", rt.auth(), rt.user(), rt.perm("/alert-subscribes"), rt.alertSubscribeGet)
+ 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)
+
+ if rt.Center.AnonymousAccess.AlertDetail {
+ pages.GET("/alert-cur-event/:eid", rt.alertCurEventGet)
+ pages.GET("/alert-his-event/:eid", rt.alertHisEventGet)
+ } else {
+ pages.GET("/alert-cur-event/:eid", rt.auth(), rt.alertCurEventGet)
+ pages.GET("/alert-his-event/:eid", rt.auth(), rt.alertHisEventGet)
+ }
+
+ // card logic
+ pages.GET("/alert-cur-events/list", rt.auth(), rt.alertCurEventsList)
+ pages.GET("/alert-cur-events/card", rt.auth(), rt.alertCurEventsCard)
+ pages.POST("/alert-cur-events/card/details", rt.auth(), rt.alertCurEventsCardDetails)
+ pages.GET("/alert-his-events/list", rt.auth(), rt.alertHisEventsList)
+ pages.DELETE("/alert-cur-events", rt.auth(), rt.user(), rt.perm("/alert-cur-events/del"), rt.alertCurEventDel)
+
+ pages.GET("/alert-aggr-views", rt.auth(), rt.alertAggrViewGets)
+ pages.DELETE("/alert-aggr-views", rt.auth(), rt.user(), rt.alertAggrViewDel)
+ pages.POST("/alert-aggr-views", rt.auth(), rt.user(), rt.alertAggrViewAdd)
+ pages.PUT("/alert-aggr-views", rt.auth(), rt.user(), rt.alertAggrViewPut)
+
+ pages.GET("/busi-group/:id/task-tpls", rt.auth(), rt.user(), rt.perm("/job-tpls"), rt.bgro(), rt.taskTplGets)
+ pages.POST("/busi-group/:id/task-tpls", rt.auth(), rt.user(), rt.perm("/job-tpls/add"), rt.bgrw(), rt.taskTplAdd)
+ pages.DELETE("/busi-group/:id/task-tpl/:tid", rt.auth(), rt.user(), rt.perm("/job-tpls/del"), rt.bgrw(), rt.taskTplDel)
+ pages.POST("/busi-group/:id/task-tpls/tags", rt.auth(), rt.user(), rt.perm("/job-tpls/put"), rt.bgrw(), rt.taskTplBindTags)
+ pages.DELETE("/busi-group/:id/task-tpls/tags", rt.auth(), rt.user(), rt.perm("/job-tpls/put"), rt.bgrw(), rt.taskTplUnbindTags)
+ pages.GET("/busi-group/:id/task-tpl/:tid", rt.auth(), rt.user(), rt.perm("/job-tpls"), rt.bgro(), rt.taskTplGet)
+ pages.PUT("/busi-group/:id/task-tpl/:tid", rt.auth(), rt.user(), rt.perm("/job-tpls/put"), rt.bgrw(), rt.taskTplPut)
+
+ pages.GET("/busi-group/:id/tasks", rt.auth(), rt.user(), rt.perm("/job-tasks"), rt.bgro(), rt.taskGets)
+ pages.POST("/busi-group/:id/tasks", rt.auth(), rt.user(), rt.perm("/job-tasks/add"), rt.bgrw(), rt.taskAdd)
+ pages.GET("/busi-group/:id/task/*url", rt.auth(), rt.user(), rt.perm("/job-tasks"), rt.taskProxy)
+ pages.PUT("/busi-group/:id/task/*url", rt.auth(), rt.user(), rt.perm("/job-tasks/put"), rt.bgrw(), rt.taskProxy)
+
+ pages.GET("/servers", rt.auth(), rt.admin(), rt.serversGet)
+ pages.GET("/server-clusters", rt.auth(), rt.admin(), rt.serverClustersGet)
+
+ pages.POST("/datasource/list", rt.auth(), rt.datasourceList)
+ pages.POST("/datasource/plugin/list", rt.auth(), rt.pluginList)
+ pages.POST("/datasource/upsert", rt.auth(), rt.admin(), rt.datasourceUpsert)
+ pages.POST("/datasource/desc", rt.auth(), rt.admin(), rt.datasourceGet)
+ pages.POST("/datasource/status/update", rt.auth(), rt.admin(), rt.datasourceUpdataStatus)
+ pages.DELETE("/datasource/", rt.auth(), rt.admin(), rt.datasourceDel)
+
+ pages.GET("/roles", rt.auth(), rt.admin(), rt.roleGets)
+ pages.POST("/roles", rt.auth(), rt.admin(), rt.roleAdd)
+ pages.PUT("/roles", rt.auth(), rt.admin(), rt.rolePut)
+ pages.DELETE("/role/:id", rt.auth(), rt.admin(), rt.roleDel)
+
+ pages.GET("/role/:id/ops", rt.auth(), rt.admin(), rt.operationOfRole)
+ pages.PUT("/role/:id/ops", rt.auth(), rt.admin(), rt.roleBindOperation)
+ pages.GET("operation", rt.operations)
+
+ pages.GET("/notify-tpls", rt.auth(), rt.admin(), rt.notifyTplGets)
+ pages.PUT("/notify-tpl/content", rt.auth(), rt.admin(), rt.notifyTplUpdateContent)
+ pages.PUT("/notify-tpl", rt.auth(), rt.admin(), rt.notifyTplUpdate)
+ pages.POST("/notify-tpl/preview", rt.auth(), rt.admin(), rt.notifyTplPreview)
+
+ pages.GET("/sso-configs", rt.auth(), rt.admin(), rt.ssoConfigGets)
+ pages.PUT("/sso-config", rt.auth(), rt.admin(), rt.ssoConfigUpdate)
+
+ pages.GET("/webhooks", rt.auth(), rt.admin(), rt.webhookGets)
+ pages.PUT("/webhooks", rt.auth(), rt.admin(), rt.webhookPuts)
+
+ pages.GET("/notify-script", rt.auth(), rt.admin(), rt.notifyScriptGet)
+ pages.PUT("/notify-script", rt.auth(), rt.admin(), rt.notifyScriptPut)
+
+ pages.GET("/notify-channel", rt.auth(), rt.admin(), rt.notifyChannelGets)
+ pages.PUT("/notify-channel", rt.auth(), rt.admin(), rt.notifyChannelPuts)
+
+ pages.GET("/notify-contact", rt.auth(), rt.admin(), rt.notifyContactGets)
+ pages.PUT("/notify-contact", rt.auth(), rt.admin(), rt.notifyContactPuts)
+ }
+
+ service := r.Group("/v1/n9e")
+
+ if len(rt.Center.BasicAuth) > 0 {
+ service.Use(gin.BasicAuth(rt.Center.BasicAuth))
+ }
+ {
+ service.Any("/prometheus/*url", rt.dsProxy)
+ service.POST("/users", rt.userAddPost)
+ service.GET("/users", rt.userFindAll)
+
+ service.GET("/targets", rt.targetGets)
+ service.GET("/targets/tags", rt.targetGetTags)
+ service.POST("/targets/tags", rt.targetBindTagsByService)
+ service.DELETE("/targets/tags", rt.targetUnbindTagsByService)
+ service.PUT("/targets/note", rt.targetUpdateNoteByService)
+
+ service.POST("/alert-rules", rt.alertRuleAddByService)
+ service.DELETE("/alert-rules", rt.alertRuleDelByService)
+ service.PUT("/alert-rule/:arid", rt.alertRulePutByService)
+ service.GET("/alert-rule/:arid", rt.alertRuleGet)
+ service.GET("/alert-rules", rt.alertRulesGetByService)
+
+ service.GET("/alert-mutes", rt.alertMuteGets)
+ service.POST("/alert-mutes", rt.alertMuteAddByService)
+ service.DELETE("/alert-mutes", rt.alertMuteDel)
+
+ service.GET("/alert-cur-events", rt.alertCurEventsList)
+ service.GET("/alert-his-events", rt.alertHisEventsList)
+ service.GET("/alert-his-event/:eid", rt.alertHisEventGet)
+
+ service.GET("/config/:id", rt.configGet)
+ service.GET("/configs", rt.configsGet)
+ service.PUT("/configs", rt.configsPut)
+ service.POST("/configs", rt.configsPost)
+ service.DELETE("/configs", rt.configsDel)
+
+ service.POST("/conf-prop/encrypt", rt.confPropEncrypt)
+ service.POST("/conf-prop/decrypt", rt.confPropDecrypt)
+ }
+
+ rt.configNoRoute(r)
+}
+
+func Render(c *gin.Context, data, msg interface{}) {
+ if msg == nil {
+ if data == nil {
+ data = struct{}{}
+ }
+ c.JSON(http.StatusOK, gin.H{"data": data, "error": ""})
+ } else {
+ c.JSON(http.StatusOK, gin.H{"error": gin.H{"message": msg}})
+ }
+}
+
+func Dangerous(c *gin.Context, v interface{}, code ...int) {
+ if v == nil {
+ return
+ }
+
+ switch t := v.(type) {
+ case string:
+ if t != "" {
+ c.JSON(http.StatusOK, gin.H{"error": gin.H{"message": v}})
+ }
+ case error:
+ c.JSON(http.StatusOK, gin.H{"error": gin.H{"message": t.Error()}})
+ }
+}
diff --git a/src/webapi/router/router_alert_aggr_view.go b/center/router/router_alert_aggr_view.go
similarity index 61%
rename from src/webapi/router/router_alert_aggr_view.go
rename to center/router/router_alert_aggr_view.go
index 57780144786ae6415dd6c224ac842071de3add8f..20a0bbc33d9a7543595ceb627faa2a023bbf0f37 100644
--- a/src/webapi/router/router_alert_aggr_view.go
+++ b/center/router/router_alert_aggr_view.go
@@ -3,19 +3,20 @@ package router
import (
"net/http"
- "github.com/didi/nightingale/v5/src/models"
+ "github.com/ccfos/nightingale/v6/models"
+
"github.com/gin-gonic/gin"
"github.com/toolkits/pkg/ginx"
)
// no param
-func alertAggrViewGets(c *gin.Context) {
- lst, err := models.AlertAggrViewGets(c.MustGet("userid"))
+func (rt *Router) alertAggrViewGets(c *gin.Context) {
+ lst, err := models.AlertAggrViewGets(rt.Ctx, c.MustGet("userid"))
ginx.NewRender(c).Data(lst, err)
}
// body: name, rule, cate
-func alertAggrViewAdd(c *gin.Context) {
+func (rt *Router) alertAggrViewAdd(c *gin.Context) {
var f models.AlertAggrView
ginx.BindJSON(c, &f)
@@ -27,31 +28,31 @@ func alertAggrViewAdd(c *gin.Context) {
f.Id = 0
f.CreateBy = me.Id
- ginx.Dangerous(f.Add())
+ ginx.Dangerous(f.Add(rt.Ctx))
ginx.NewRender(c).Data(f, nil)
}
// body: ids
-func alertAggrViewDel(c *gin.Context) {
+func (rt *Router) alertAggrViewDel(c *gin.Context) {
var f idsForm
ginx.BindJSON(c, &f)
f.Verify()
me := c.MustGet("user").(*models.User)
if me.IsAdmin() {
- ginx.NewRender(c).Message(models.AlertAggrViewDel(f.Ids))
+ ginx.NewRender(c).Message(models.AlertAggrViewDel(rt.Ctx, f.Ids))
} else {
- ginx.NewRender(c).Message(models.AlertAggrViewDel(f.Ids, me.Id))
+ ginx.NewRender(c).Message(models.AlertAggrViewDel(rt.Ctx, f.Ids, me.Id))
}
}
// body: id, name, rule, cate
-func alertAggrViewPut(c *gin.Context) {
+func (rt *Router) alertAggrViewPut(c *gin.Context) {
var f models.AlertAggrView
ginx.BindJSON(c, &f)
- view, err := models.AlertAggrViewGet("id = ?", f.Id)
+ view, err := models.AlertAggrViewGet(rt.Ctx, "id = ?", f.Id)
ginx.Dangerous(err)
if view == nil {
@@ -69,5 +70,5 @@ func alertAggrViewPut(c *gin.Context) {
}
}
- ginx.NewRender(c).Message(view.Update(f.Name, f.Rule, f.Cate, me.Id))
+ ginx.NewRender(c).Message(view.Update(rt.Ctx, f.Name, f.Rule, f.Cate, me.Id))
}
diff --git a/src/webapi/router/router_alert_cur_event.go b/center/router/router_alert_cur_event.go
similarity index 70%
rename from src/webapi/router/router_alert_cur_event.go
rename to center/router/router_alert_cur_event.go
index 1b304dc6eb28ea59e86a62c10703d30049adcb1f..d7a207b917a08dc3e62ff014219702b152e861e1 100644
--- a/src/webapi/router/router_alert_cur_event.go
+++ b/center/router/router_alert_cur_event.go
@@ -5,10 +5,10 @@ import (
"sort"
"strings"
+ "github.com/ccfos/nightingale/v6/models"
+
"github.com/gin-gonic/gin"
"github.com/toolkits/pkg/ginx"
-
- "github.com/didi/nightingale/v5/src/models"
)
func parseAggrRules(c *gin.Context) []*models.AggrRule {
@@ -38,14 +38,20 @@ func parseAggrRules(c *gin.Context) []*models.AggrRule {
return rules
}
-func alertCurEventsCard(c *gin.Context) {
+func (rt *Router) alertCurEventsCard(c *gin.Context) {
stime, etime := getTimeRange(c)
severity := ginx.QueryInt(c, "severity", -1)
query := ginx.QueryStr(c, "query", "")
busiGroupId := ginx.QueryInt64(c, "bgid", 0)
- clusters := queryClusters(c)
+ dsIds := queryDatasourceIds(c)
rules := parseAggrRules(c)
- prod := ginx.QueryStr(c, "prod", "")
+
+ prod := ginx.QueryStr(c, "prods", "")
+ prods := []string{}
+ if prod != "" {
+ prods = strings.Split(prod, ",")
+ }
+
cate := ginx.QueryStr(c, "cate", "$all")
cates := []string{}
if cate != "$all" {
@@ -53,7 +59,7 @@ func alertCurEventsCard(c *gin.Context) {
}
// 最多获取50000个，获取太多也没啥意义
- list, err := models.AlertCurEventGets(prod, busiGroupId, stime, etime, severity, clusters, cates, query, 50000, 0)
+ list, err := models.AlertCurEventGets(rt.Ctx, prods, busiGroupId, stime, etime, severity, dsIds, cates, query, 50000, 0)
ginx.Dangerous(err)
cardmap := make(map[string]*AlertCard)
@@ -104,15 +110,15 @@ type AlertCard struct {
Severity int `json:"severity"`
}
-func alertCurEventsCardDetails(c *gin.Context) {
+func (rt *Router) alertCurEventsCardDetails(c *gin.Context) {
var f idsForm
ginx.BindJSON(c, &f)
- list, err := models.AlertCurEventGetByIds(f.Ids)
+ list, err := models.AlertCurEventGetByIds(rt.Ctx, f.Ids)
if err == nil {
cache := make(map[int64]*models.UserGroup)
for i := 0; i < len(list); i++ {
- list[i].FillNotifyGroups(cache)
+ list[i].FillNotifyGroups(rt.Ctx, cache)
}
}
@@ -120,29 +126,39 @@ func alertCurEventsCardDetails(c *gin.Context) {
}
// 列表方式，拉取活跃告警
-func alertCurEventsList(c *gin.Context) {
+func (rt *Router) alertCurEventsList(c *gin.Context) {
stime, etime := getTimeRange(c)
severity := ginx.QueryInt(c, "severity", -1)
query := ginx.QueryStr(c, "query", "")
limit := ginx.QueryInt(c, "limit", 20)
busiGroupId := ginx.QueryInt64(c, "bgid", 0)
- clusters := queryClusters(c)
- prod := ginx.QueryStr(c, "prod", "")
+ dsIds := queryDatasourceIds(c)
+
+ prod := ginx.QueryStr(c, "prods", "")
+ if prod == "" {
+ prod = ginx.QueryStr(c, "rule_prods", "")
+ }
+
+ prods := []string{}
+ if prod != "" {
+ prods = strings.Split(prod, ",")
+ }
+
cate := ginx.QueryStr(c, "cate", "$all")
cates := []string{}
if cate != "$all" {
cates = strings.Split(cate, ",")
}
- total, err := models.AlertCurEventTotal(prod, busiGroupId, stime, etime, severity, clusters, cates, query)
+ total, err := models.AlertCurEventTotal(rt.Ctx, prods, busiGroupId, stime, etime, severity, dsIds, cates, query)
ginx.Dangerous(err)
- list, err := models.AlertCurEventGets(prod, busiGroupId, stime, etime, severity, clusters, cates, query, limit, ginx.Offset(c, limit))
+ list, err := models.AlertCurEventGets(rt.Ctx, prods, busiGroupId, stime, etime, severity, dsIds, cates, query, limit, ginx.Offset(c, limit))
ginx.Dangerous(err)
cache := make(map[int64]*models.UserGroup)
for i := 0; i < len(list); i++ {
- list[i].FillNotifyGroups(cache)
+ list[i].FillNotifyGroups(rt.Ctx, cache)
}
ginx.NewRender(c).Data(gin.H{
@@ -151,7 +167,7 @@ func alertCurEventsList(c *gin.Context) {
}, nil)
}
-func alertCurEventDel(c *gin.Context) {
+func (rt *Router) alertCurEventDel(c *gin.Context) {
var f idsForm
ginx.BindJSON(c, &f)
f.Verify()
@@ -159,21 +175,21 @@ func alertCurEventDel(c *gin.Context) {
set := make(map[int64]struct{})
for i := 0; i < len(f.Ids); i++ {
- event, err := models.AlertCurEventGetById(f.Ids[i])
+ event, err := models.AlertCurEventGetById(rt.Ctx, f.Ids[i])
ginx.Dangerous(err)
if _, has := set[event.GroupId]; !has {
- bgrwCheck(c, event.GroupId)
+ rt.bgrwCheck(c, event.GroupId)
set[event.GroupId] = struct{}{}
}
}
- ginx.NewRender(c).Message(models.AlertCurEventDel(f.Ids))
+ ginx.NewRender(c).Message(models.AlertCurEventDel(rt.Ctx, f.Ids))
}
-func alertCurEventGet(c *gin.Context) {
+func (rt *Router) alertCurEventGet(c *gin.Context) {
eid := ginx.UrlParamInt64(c, "eid")
- event, err := models.AlertCurEventGetById(eid)
+ event, err := models.AlertCurEventGetById(rt.Ctx, eid)
ginx.Dangerous(err)
if event == nil {
diff --git a/src/webapi/router/router_alert_his_event.go b/center/router/router_alert_his_event.go
similarity index 61%
rename from src/webapi/router/router_alert_his_event.go
rename to center/router/router_alert_his_event.go
index 555d47463bfa3e5343d4c0d4cb219ce90ce526af..b1a50d085892f79d83a35f50b06598902103ca4c 100644
--- a/src/webapi/router/router_alert_his_event.go
+++ b/center/router/router_alert_his_event.go
@@ -4,10 +4,10 @@ import (
"strings"
"time"
+ "github.com/ccfos/nightingale/v6/models"
+
"github.com/gin-gonic/gin"
"github.com/toolkits/pkg/ginx"
-
- "github.com/didi/nightingale/v5/src/models"
)
func getTimeRange(c *gin.Context) (stime, etime int64) {
@@ -26,7 +26,7 @@ func getTimeRange(c *gin.Context) (stime, etime int64) {
return
}
-func alertHisEventsList(c *gin.Context) {
+func (rt *Router) alertHisEventsList(c *gin.Context) {
stime, etime := getTimeRange(c)
severity := ginx.QueryInt(c, "severity", -1)
@@ -34,23 +34,33 @@ func alertHisEventsList(c *gin.Context) {
query := ginx.QueryStr(c, "query", "")
limit := ginx.QueryInt(c, "limit", 20)
busiGroupId := ginx.QueryInt64(c, "bgid", 0)
- clusters := queryClusters(c)
- prod := ginx.QueryStr(c, "prod", "")
+ dsIds := queryDatasourceIds(c)
+
+ prod := ginx.QueryStr(c, "prods", "")
+ if prod == "" {
+ prod = ginx.QueryStr(c, "rule_prods", "")
+ }
+
+ prods := []string{}
+ if prod != "" {
+ prods = strings.Split(prod, ",")
+ }
+
cate := ginx.QueryStr(c, "cate", "$all")
cates := []string{}
if cate != "$all" {
cates = strings.Split(cate, ",")
}
- total, err := models.AlertHisEventTotal(prod, busiGroupId, stime, etime, severity, recovered, clusters, cates, query)
+ total, err := models.AlertHisEventTotal(rt.Ctx, prods, busiGroupId, stime, etime, severity, recovered, dsIds, cates, query)
ginx.Dangerous(err)
- list, err := models.AlertHisEventGets(prod, busiGroupId, stime, etime, severity, recovered, clusters, cates, query, limit, ginx.Offset(c, limit))
+ list, err := models.AlertHisEventGets(rt.Ctx, prods, busiGroupId, stime, etime, severity, recovered, dsIds, cates, query, limit, ginx.Offset(c, limit))
ginx.Dangerous(err)
cache := make(map[int64]*models.UserGroup)
for i := 0; i < len(list); i++ {
- list[i].FillNotifyGroups(cache)
+ list[i].FillNotifyGroups(rt.Ctx, cache)
}
ginx.NewRender(c).Data(gin.H{
@@ -59,9 +69,9 @@ func alertHisEventsList(c *gin.Context) {
}, nil)
}
-func alertHisEventGet(c *gin.Context) {
+func (rt *Router) alertHisEventGet(c *gin.Context) {
eid := ginx.UrlParamInt64(c, "eid")
- event, err := models.AlertHisEventGetById(eid)
+ event, err := models.AlertHisEventGetById(rt.Ctx, eid)
ginx.Dangerous(err)
if event == nil {
diff --git a/src/webapi/router/router_alert_rule.go b/center/router/router_alert_rule.go
similarity index 63%
rename from src/webapi/router/router_alert_rule.go
rename to center/router/router_alert_rule.go
index 9ada06c11bc271219fcce8eaa52bba5fe9c782e2..406bab0a323459323001a882fe24bd1c089325f6 100644
--- a/src/webapi/router/router_alert_rule.go
+++ b/center/router/router_alert_rule.go
@@ -1,31 +1,32 @@
package router
import (
+ "encoding/json"
"net/http"
"strings"
"time"
+ "github.com/ccfos/nightingale/v6/models"
+
"github.com/gin-gonic/gin"
"github.com/toolkits/pkg/ginx"
"github.com/toolkits/pkg/i18n"
-
- "github.com/didi/nightingale/v5/src/models"
)
// Return all, front-end search and paging
-func alertRuleGets(c *gin.Context) {
+func (rt *Router) alertRuleGets(c *gin.Context) {
busiGroupId := ginx.UrlParamInt64(c, "id")
- ars, err := models.AlertRuleGets(busiGroupId)
+ ars, err := models.AlertRuleGets(rt.Ctx, busiGroupId)
if err == nil {
cache := make(map[int64]*models.UserGroup)
for i := 0; i < len(ars); i++ {
- ars[i].FillNotifyGroups(cache)
+ ars[i].FillNotifyGroups(rt.Ctx, cache)
}
}
ginx.NewRender(c).Data(ars, err)
}
-func alertRulesGetByService(c *gin.Context) {
+func (rt *Router) alertRulesGetByService(c *gin.Context) {
prods := strings.Split(ginx.QueryStr(c, "prods", ""), ",")
query := ginx.QueryStr(c, "query", "")
algorithm := ginx.QueryStr(c, "algorithm", "")
@@ -37,18 +38,18 @@ func alertRulesGetByService(c *gin.Context) {
}
disabled := ginx.QueryInt(c, "disabled", -1)
- ars, err := models.AlertRulesGetsBy(prods, query, algorithm, cluster, cates, disabled)
+ ars, err := models.AlertRulesGetsBy(rt.Ctx, prods, query, algorithm, cluster, cates, disabled)
if err == nil {
cache := make(map[int64]*models.UserGroup)
for i := 0; i < len(ars); i++ {
- ars[i].FillNotifyGroups(cache)
+ ars[i].FillNotifyGroups(rt.Ctx, cache)
}
}
ginx.NewRender(c).Data(ars, err)
}
// single or import
-func alertRuleAddByFE(c *gin.Context) {
+func (rt *Router) alertRuleAddByFE(c *gin.Context) {
username := c.MustGet("username").(string)
var lst []models.AlertRule
@@ -60,12 +61,12 @@ func alertRuleAddByFE(c *gin.Context) {
}
bgid := ginx.UrlParamInt64(c, "id")
- reterr := alertRuleAdd(lst, username, bgid, c.GetHeader("X-Language"))
+ reterr := rt.alertRuleAdd(lst, username, bgid, c.GetHeader("X-Language"))
ginx.NewRender(c).Data(reterr, nil)
}
-func alertRuleAddByService(c *gin.Context) {
+func (rt *Router) alertRuleAddByService(c *gin.Context) {
var lst []models.AlertRule
ginx.BindJSON(c, &lst)
@@ -73,11 +74,11 @@ func alertRuleAddByService(c *gin.Context) {
if count == 0 {
ginx.Bomb(http.StatusBadRequest, "input json is empty")
}
- reterr := alertRuleAddForService(lst, "")
+ reterr := rt.alertRuleAddForService(lst, "")
ginx.NewRender(c).Data(reterr, nil)
}
-func alertRuleAddForService(lst []models.AlertRule, username string) map[string]string {
+func (rt *Router) alertRuleAddForService(lst []models.AlertRule, username string) map[string]string {
count := len(lst)
// alert rule name -> error string
reterr := make(map[string]string)
@@ -93,7 +94,7 @@ func alertRuleAddForService(lst []models.AlertRule, username string) map[string]
continue
}
- if err := lst[i].Add(); err != nil {
+ if err := lst[i].Add(rt.Ctx, models.GetChannelMap(rt.Ctx)); err != nil {
reterr[lst[i].Name] = err.Error()
} else {
reterr[lst[i].Name] = ""
@@ -102,7 +103,7 @@ func alertRuleAddForService(lst []models.AlertRule, username string) map[string]
return reterr
}
-func alertRuleAdd(lst []models.AlertRule, username string, bgid int64, lang string) map[string]string {
+func (rt *Router) alertRuleAdd(lst []models.AlertRule, username string, bgid int64, lang string) map[string]string {
count := len(lst)
// alert rule name -> error string
reterr := make(map[string]string)
@@ -119,7 +120,7 @@ func alertRuleAdd(lst []models.AlertRule, username string, bgid int64, lang stri
continue
}
- if err := lst[i].Add(); err != nil {
+ if err := lst[i].Add(rt.Ctx, models.GetChannelMap(rt.Ctx)); err != nil {
reterr[lst[i].Name] = i18n.Sprintf(lang, err.Error())
} else {
reterr[lst[i].Name] = ""
@@ -128,28 +129,28 @@ func alertRuleAdd(lst []models.AlertRule, username string, bgid int64, lang stri
return reterr
}
-func alertRuleDel(c *gin.Context) {
+func (rt *Router) alertRuleDel(c *gin.Context) {
var f idsForm
ginx.BindJSON(c, &f)
f.Verify()
// param(busiGroupId) for protect
- ginx.NewRender(c).Message(models.AlertRuleDels(f.Ids, ginx.UrlParamInt64(c, "id")))
+ ginx.NewRender(c).Message(models.AlertRuleDels(rt.Ctx, f.Ids, ginx.UrlParamInt64(c, "id")))
}
-func alertRuleDelByService(c *gin.Context) {
+func (rt *Router) alertRuleDelByService(c *gin.Context) {
var f idsForm
ginx.BindJSON(c, &f)
f.Verify()
- ginx.NewRender(c).Message(models.AlertRuleDels(f.Ids))
+ ginx.NewRender(c).Message(models.AlertRuleDels(rt.Ctx, f.Ids))
}
-func alertRulePutByFE(c *gin.Context) {
+func (rt *Router) alertRulePutByFE(c *gin.Context) {
var f models.AlertRule
ginx.BindJSON(c, &f)
arid := ginx.UrlParamInt64(c, "arid")
- ar, err := models.AlertRuleGetById(arid)
+ ar, err := models.AlertRuleGetById(rt.Ctx, arid)
ginx.Dangerous(err)
if ar == nil {
@@ -157,25 +158,25 @@ func alertRulePutByFE(c *gin.Context) {
return
}
- bgrwCheck(c, ar.GroupId)
+ rt.bgrwCheck(c, ar.GroupId)
f.UpdateBy = c.MustGet("username").(string)
- ginx.NewRender(c).Message(ar.Update(f))
+ ginx.NewRender(c).Message(ar.Update(rt.Ctx, f, models.GetChannelMap(rt.Ctx)))
}
-func alertRulePutByService(c *gin.Context) {
+func (rt *Router) alertRulePutByService(c *gin.Context) {
var f models.AlertRule
ginx.BindJSON(c, &f)
arid := ginx.UrlParamInt64(c, "arid")
- ar, err := models.AlertRuleGetById(arid)
+ ar, err := models.AlertRuleGetById(rt.Ctx, arid)
ginx.Dangerous(err)
if ar == nil {
ginx.NewRender(c, http.StatusNotFound).Message("No such AlertRule")
return
}
- ginx.NewRender(c).Message(ar.Update(f))
+ ginx.NewRender(c).Message(ar.Update(rt.Ctx, f, models.GetChannelMap(rt.Ctx)))
}
type alertRuleFieldForm struct {
@@ -185,7 +186,7 @@ type alertRuleFieldForm struct {
}
// update one field: cluster note severity disabled prom_eval_interval prom_for_duration notify_channels notify_groups notify_recovered notify_repeat_step callbacks runbook_url append_tags
-func alertRulePutFields(c *gin.Context) {
+func (rt *Router) alertRulePutFields(c *gin.Context) {
var f alertRuleFieldForm
ginx.BindJSON(c, &f)
@@ -197,7 +198,7 @@ func alertRulePutFields(c *gin.Context) {
f.Fields["update_at"] = time.Now().Unix()
for i := 0; i < len(f.Ids); i++ {
- ar, err := models.AlertRuleGetById(f.Ids[i])
+ ar, err := models.AlertRuleGetById(rt.Ctx, f.Ids[i])
ginx.Dangerous(err)
if ar == nil {
@@ -209,7 +210,7 @@ func alertRulePutFields(c *gin.Context) {
if callbacks, has := f.Fields["callbacks"]; has {
callback := callbacks.(string)
if !strings.Contains(ar.Callbacks, callback) {
- ginx.Dangerous(ar.UpdateFieldsMap(map[string]interface{}{"callbacks": ar.Callbacks + " " + callback}))
+ ginx.Dangerous(ar.UpdateFieldsMap(rt.Ctx, map[string]interface{}{"callbacks": ar.Callbacks + " " + callback}))
continue
}
}
@@ -219,21 +220,29 @@ func alertRulePutFields(c *gin.Context) {
// 删除一个 callback 地址
if callbacks, has := f.Fields["callbacks"]; has {
callback := callbacks.(string)
- ginx.Dangerous(ar.UpdateFieldsMap(map[string]interface{}{"callbacks": strings.ReplaceAll(ar.Callbacks, callback, "")}))
+ ginx.Dangerous(ar.UpdateFieldsMap(rt.Ctx, map[string]interface{}{"callbacks": strings.ReplaceAll(ar.Callbacks, callback, "")}))
continue
}
}
- ginx.Dangerous(ar.UpdateFieldsMap(f.Fields))
+ for k, v := range f.Fields {
+ if k == "datasource_ids" {
+ b, err := json.Marshal(v)
+ ginx.Dangerous(err)
+ f.Fields[k] = string(b)
+ }
+ }
+
+ ginx.Dangerous(ar.UpdateFieldsMap(rt.Ctx, f.Fields))
}
ginx.NewRender(c).Message(nil)
}
-func alertRuleGet(c *gin.Context) {
+func (rt *Router) alertRuleGet(c *gin.Context) {
arid := ginx.UrlParamInt64(c, "arid")
- ar, err := models.AlertRuleGetById(arid)
+ ar, err := models.AlertRuleGetById(rt.Ctx, arid)
ginx.Dangerous(err)
if ar == nil {
@@ -241,6 +250,8 @@ func alertRuleGet(c *gin.Context) {
return
}
- err = ar.FillNotifyGroups(make(map[int64]*models.UserGroup))
+ err = ar.FillNotifyGroups(rt.Ctx, make(map[int64]*models.UserGroup))
+ ginx.Dangerous(err)
+
ginx.NewRender(c).Data(ar, err)
}
diff --git a/src/webapi/router/router_alert_subscribe.go b/center/router/router_alert_subscribe.go
similarity index 59%
rename from src/webapi/router/router_alert_subscribe.go
rename to center/router/router_alert_subscribe.go
index 431cc45a65be793e4ccae7c0e5f76e61753d2eb0..b8d762321e332f6846d70ea2e2131e04ffd59ef1 100644
--- a/src/webapi/router/router_alert_subscribe.go
+++ b/center/router/router_alert_subscribe.go
@@ -4,34 +4,38 @@ import (
"net/http"
"time"
+ "github.com/ccfos/nightingale/v6/models"
+
"github.com/gin-gonic/gin"
"github.com/toolkits/pkg/ginx"
-
- "github.com/didi/nightingale/v5/src/models"
)
// Return all, front-end search and paging
-func alertSubscribeGets(c *gin.Context) {
+func (rt *Router) alertSubscribeGets(c *gin.Context) {
bgid := ginx.UrlParamInt64(c, "id")
- lst, err := models.AlertSubscribeGets(bgid)
+ lst, err := models.AlertSubscribeGets(rt.Ctx, bgid)
if err == nil {
ugcache := make(map[int64]*models.UserGroup)
for i := 0; i < len(lst); i++ {
- ginx.Dangerous(lst[i].FillUserGroups(ugcache))
+ ginx.Dangerous(lst[i].FillUserGroups(rt.Ctx, ugcache))
}
rulecache := make(map[int64]string)
for i := 0; i < len(lst); i++ {
- ginx.Dangerous(lst[i].FillRuleName(rulecache))
+ ginx.Dangerous(lst[i].FillRuleName(rt.Ctx, rulecache))
+ }
+
+ for i := 0; i < len(lst); i++ {
+ ginx.Dangerous(lst[i].FillDatasourceIds(rt.Ctx))
}
}
ginx.NewRender(c).Data(lst, err)
}
-func alertSubscribeGet(c *gin.Context) {
+func (rt *Router) alertSubscribeGet(c *gin.Context) {
subid := ginx.UrlParamInt64(c, "sid")
- sub, err := models.AlertSubscribeGet("id=?", subid)
+ sub, err := models.AlertSubscribeGet(rt.Ctx, "id=?", subid)
ginx.Dangerous(err)
if sub == nil {
@@ -40,15 +44,17 @@ func alertSubscribeGet(c *gin.Context) {
}
ugcache := make(map[int64]*models.UserGroup)
- ginx.Dangerous(sub.FillUserGroups(ugcache))
+ ginx.Dangerous(sub.FillUserGroups(rt.Ctx, ugcache))
rulecache := make(map[int64]string)
- ginx.Dangerous(sub.FillRuleName(rulecache))
+ ginx.Dangerous(sub.FillRuleName(rt.Ctx, rulecache))
+ ginx.Dangerous(sub.FillDatasourceIds(rt.Ctx))
+ ginx.Dangerous(sub.DB2FE())
ginx.NewRender(c).Data(sub, nil)
}
-func alertSubscribeAdd(c *gin.Context) {
+func (rt *Router) alertSubscribeAdd(c *gin.Context) {
var f models.AlertSubscribe
ginx.BindJSON(c, &f)
@@ -61,10 +67,10 @@ func alertSubscribeAdd(c *gin.Context) {
ginx.Bomb(http.StatusBadRequest, "group_id invalid")
}
- ginx.NewRender(c).Message(f.Add())
+ ginx.NewRender(c).Message(f.Add(rt.Ctx))
}
-func alertSubscribePut(c *gin.Context) {
+func (rt *Router) alertSubscribePut(c *gin.Context) {
var fs []models.AlertSubscribe
ginx.BindJSON(c, &fs)
@@ -74,6 +80,7 @@ func alertSubscribePut(c *gin.Context) {
fs[i].UpdateBy = username
fs[i].UpdateAt = timestamp
ginx.Dangerous(fs[i].Update(
+ rt.Ctx,
"name",
"disabled",
"cluster",
@@ -86,16 +93,20 @@ func alertSubscribePut(c *gin.Context) {
"user_group_ids",
"update_at",
"update_by",
+ "webhooks",
+ "for_duration",
+ "redefine_webhooks",
+ "datasource_ids",
))
}
ginx.NewRender(c).Message(nil)
}
-func alertSubscribeDel(c *gin.Context) {
+func (rt *Router) alertSubscribeDel(c *gin.Context) {
var f idsForm
ginx.BindJSON(c, &f)
f.Verify()
- ginx.NewRender(c).Message(models.AlertSubscribeDel(f.Ids))
+ ginx.NewRender(c).Message(models.AlertSubscribeDel(rt.Ctx, f.Ids))
}
diff --git a/src/webapi/router/router_board.go b/center/router/router_board.go
similarity index 54%
rename from src/webapi/router/router_board.go
rename to center/router/router_board.go
index a59309ace82ccf1570326b28a5125a3a4d16bcaa..0abe402689c4e0b1290d17fce2736d906b57035f 100644
--- a/src/webapi/router/router_board.go
+++ b/center/router/router_board.go
@@ -4,7 +4,8 @@ import (
"net/http"
"time"
- "github.com/didi/nightingale/v5/src/models"
+ "github.com/ccfos/nightingale/v6/models"
+
"github.com/gin-gonic/gin"
"github.com/google/uuid"
"github.com/toolkits/pkg/ginx"
@@ -18,7 +19,7 @@ type boardForm struct {
Public int `json:"public"`
}
-func boardAdd(c *gin.Context) {
+func (rt *Router) boardAdd(c *gin.Context) {
var f boardForm
ginx.BindJSON(c, &f)
@@ -34,19 +35,19 @@ func boardAdd(c *gin.Context) {
UpdateBy: me.Username,
}
- err := board.Add()
+ err := board.Add(rt.Ctx)
ginx.Dangerous(err)
if f.Configs != "" {
- ginx.Dangerous(models.BoardPayloadSave(board.Id, f.Configs))
+ ginx.Dangerous(models.BoardPayloadSave(rt.Ctx, board.Id, f.Configs))
}
ginx.NewRender(c).Data(board, nil)
}
-func boardGet(c *gin.Context) {
+func (rt *Router) boardGet(c *gin.Context) {
bid := ginx.UrlParamStr(c, "bid")
- board, err := models.BoardGet("id = ? or ident = ?", bid, bid)
+ board, err := models.BoardGet(rt.Ctx, "id = ? or ident = ?", bid, bid)
ginx.Dangerous(err)
if board == nil {
@@ -54,17 +55,21 @@ func boardGet(c *gin.Context) {
}
if board.Public == 0 {
- auth()(c)
- user()(c)
+ rt.auth()(c)
+ rt.user()(c)
- bgroCheck(c, board.GroupId)
+ me := c.MustGet("user").(*models.User)
+ if !me.IsAdmin() {
+ // check permission
+ rt.bgroCheck(c, board.GroupId)
+ }
}
ginx.NewRender(c).Data(board, nil)
}
-func boardPureGet(c *gin.Context) {
- board, err := models.BoardGetByID(ginx.UrlParamInt64(c, "bid"))
+func (rt *Router) boardPureGet(c *gin.Context) {
+ board, err := models.BoardGetByID(rt.Ctx, ginx.UrlParamInt64(c, "bid"))
ginx.Dangerous(err)
if board == nil {
@@ -75,7 +80,7 @@ func boardPureGet(c *gin.Context) {
}
// bgrwCheck
-func boardDel(c *gin.Context) {
+func (rt *Router) boardDel(c *gin.Context) {
var f idsForm
ginx.BindJSON(c, &f)
f.Verify()
@@ -83,24 +88,27 @@ func boardDel(c *gin.Context) {
for i := 0; i < len(f.Ids); i++ {
bid := f.Ids[i]
- board, err := models.BoardGet("id = ?", bid)
+ board, err := models.BoardGet(rt.Ctx, "id = ?", bid)
ginx.Dangerous(err)
if board == nil {
continue
}
- // check permission
- bgrwCheck(c, board.GroupId)
+ me := c.MustGet("user").(*models.User)
+ if !me.IsAdmin() {
+ // check permission
+ rt.bgrwCheck(c, board.GroupId)
+ }
- ginx.Dangerous(board.Del())
+ ginx.Dangerous(board.Del(rt.Ctx))
}
ginx.NewRender(c).Message(nil)
}
-func Board(id int64) *models.Board {
- obj, err := models.BoardGet("id=?", id)
+func (rt *Router) Board(id int64) *models.Board {
+ obj, err := models.BoardGet(rt.Ctx, "id=?", id)
ginx.Dangerous(err)
if obj == nil {
@@ -111,17 +119,19 @@ func Board(id int64) *models.Board {
}
// bgrwCheck
-func boardPut(c *gin.Context) {
+func (rt *Router) boardPut(c *gin.Context) {
var f boardForm
ginx.BindJSON(c, &f)
me := c.MustGet("user").(*models.User)
- bo := Board(ginx.UrlParamInt64(c, "bid"))
+ bo := rt.Board(ginx.UrlParamInt64(c, "bid"))
- // check permission
- bgrwCheck(c, bo.GroupId)
+ if !me.IsAdmin() {
+ // check permission
+ rt.bgrwCheck(c, bo.GroupId)
+ }
- can, err := bo.CanRenameIdent(f.Ident)
+ can, err := bo.CanRenameIdent(rt.Ctx, f.Ident)
ginx.Dangerous(err)
if !can {
@@ -134,19 +144,19 @@ func boardPut(c *gin.Context) {
bo.UpdateBy = me.Username
bo.UpdateAt = time.Now().Unix()
- err = bo.Update("name", "ident", "tags", "update_by", "update_at")
+ err = bo.Update(rt.Ctx, "name", "ident", "tags", "update_by", "update_at")
ginx.NewRender(c).Data(bo, err)
}
// bgrwCheck
-func boardPutConfigs(c *gin.Context) {
+func (rt *Router) boardPutConfigs(c *gin.Context) {
var f boardForm
ginx.BindJSON(c, &f)
me := c.MustGet("user").(*models.User)
bid := ginx.UrlParamStr(c, "bid")
- bo, err := models.BoardGet("id = ? or ident = ?", bid, bid)
+ bo, err := models.BoardGet(rt.Ctx, "id = ? or ident = ?", bid, bid)
ginx.Dangerous(err)
if bo == nil {
@@ -154,48 +164,52 @@ func boardPutConfigs(c *gin.Context) {
}
// check permission
- bgrwCheck(c, bo.GroupId)
+ if !me.IsAdmin() {
+ rt.bgrwCheck(c, bo.GroupId)
+ }
bo.UpdateBy = me.Username
bo.UpdateAt = time.Now().Unix()
- ginx.Dangerous(bo.Update("update_by", "update_at"))
+ ginx.Dangerous(bo.Update(rt.Ctx, "update_by", "update_at"))
bo.Configs = f.Configs
- ginx.Dangerous(models.BoardPayloadSave(bo.Id, f.Configs))
+ ginx.Dangerous(models.BoardPayloadSave(rt.Ctx, bo.Id, f.Configs))
ginx.NewRender(c).Data(bo, nil)
}
// bgrwCheck
-func boardPutPublic(c *gin.Context) {
+func (rt *Router) boardPutPublic(c *gin.Context) {
var f boardForm
ginx.BindJSON(c, &f)
me := c.MustGet("user").(*models.User)
- bo := Board(ginx.UrlParamInt64(c, "bid"))
+ bo := rt.Board(ginx.UrlParamInt64(c, "bid"))
// check permission
- bgrwCheck(c, bo.GroupId)
+ if !me.IsAdmin() {
+ rt.bgrwCheck(c, bo.GroupId)
+ }
bo.Public = f.Public
bo.UpdateBy = me.Username
bo.UpdateAt = time.Now().Unix()
- err := bo.Update("public", "update_by", "update_at")
+ err := bo.Update(rt.Ctx, "public", "update_by", "update_at")
ginx.NewRender(c).Data(bo, err)
}
-func boardGets(c *gin.Context) {
+func (rt *Router) boardGets(c *gin.Context) {
bgid := ginx.UrlParamInt64(c, "id")
query := ginx.QueryStr(c, "query", "")
- boards, err := models.BoardGets(bgid, query)
+ boards, err := models.BoardGetsByGroupId(rt.Ctx, bgid, query)
ginx.NewRender(c).Data(boards, err)
}
-func boardClone(c *gin.Context) {
+func (rt *Router) boardClone(c *gin.Context) {
me := c.MustGet("user").(*models.User)
- bo := Board(ginx.UrlParamInt64(c, "bid"))
+ bo := rt.Board(ginx.UrlParamInt64(c, "bid"))
newBoard := &models.Board{
Name: bo.Name + " Copy",
@@ -209,53 +223,15 @@ func boardClone(c *gin.Context) {
newBoard.Ident = uuid.NewString()
}
- ginx.Dangerous(newBoard.Add())
+ ginx.Dangerous(newBoard.Add(rt.Ctx))
// clone payload
- payload, err := models.BoardPayloadGet(bo.Id)
+ payload, err := models.BoardPayloadGet(rt.Ctx, bo.Id)
ginx.Dangerous(err)
if payload != "" {
- ginx.Dangerous(models.BoardPayloadSave(newBoard.Id, payload))
+ ginx.Dangerous(models.BoardPayloadSave(rt.Ctx, newBoard.Id, payload))
}
ginx.NewRender(c).Message(nil)
}
-
-// ---- migrate ----
-
-func migrateDashboards(c *gin.Context) {
- lst, err := models.DashboardGetAll()
- ginx.NewRender(c).Data(lst, err)
-}
-
-func migrateDashboardGet(c *gin.Context) {
- dash := Dashboard(ginx.UrlParamInt64(c, "id"))
- ginx.NewRender(c).Data(dash, nil)
-}
-
-func migrateDashboard(c *gin.Context) {
- dash := Dashboard(ginx.UrlParamInt64(c, "id"))
-
- var f boardForm
- ginx.BindJSON(c, &f)
-
- me := c.MustGet("user").(*models.User)
-
- board := &models.Board{
- GroupId: dash.GroupId,
- Name: f.Name,
- Tags: f.Tags,
- Configs: f.Configs,
- CreateBy: me.Username,
- UpdateBy: me.Username,
- }
-
- ginx.Dangerous(board.Add())
-
- if board.Configs != "" {
- ginx.Dangerous(models.BoardPayloadSave(board.Id, board.Configs))
- }
-
- ginx.NewRender(c).Message(dash.Del())
-}
diff --git a/center/router/router_builtin.go b/center/router/router_builtin.go
new file mode 100644
index 0000000000000000000000000000000000000000..83d0d149510acdcb7a9a9ae15be6d28513c113cc
--- /dev/null
+++ b/center/router/router_builtin.go
@@ -0,0 +1,317 @@
+package router
+
+import (
+ "encoding/json"
+ "fmt"
+ "net/http"
+ "path"
+ "strings"
+
+ "github.com/ccfos/nightingale/v6/models"
+
+ "github.com/gin-gonic/gin"
+ "github.com/toolkits/pkg/file"
+ "github.com/toolkits/pkg/ginx"
+ "github.com/toolkits/pkg/i18n"
+ "github.com/toolkits/pkg/logger"
+ "github.com/toolkits/pkg/runner"
+)
+
+// 创建 builtin_cate
+func (rt *Router) builtinCateFavoriteAdd(c *gin.Context) {
+ var f models.BuiltinCate
+ ginx.BindJSON(c, &f)
+
+ if f.Name == "" {
+ ginx.Bomb(http.StatusBadRequest, "name is empty")
+ }
+
+ me := c.MustGet("user").(*models.User)
+ f.UserId = me.Id
+
+ ginx.NewRender(c).Message(f.Create(rt.Ctx))
+}
+
+// 删除 builtin_cate
+func (rt *Router) builtinCateFavoriteDel(c *gin.Context) {
+ name := ginx.UrlParamStr(c, "name")
+ me := c.MustGet("user").(*models.User)
+
+ ginx.NewRender(c).Message(models.BuiltinCateDelete(rt.Ctx, name, me.Id))
+}
+
+func (rt *Router) alertRuleBuiltinList(c *gin.Context) {
+ fp := rt.Center.BuiltinIntegrationsDir
+ if fp == "" {
+ fp = path.Join(runner.Cwd, "etc", "alerts")
+ }
+
+ files, err := file.FilesUnder(fp)
+ ginx.Dangerous(err)
+
+ names := make([]string, 0, len(files))
+
+ for _, f := range files {
+ if !strings.HasSuffix(f, ".json") {
+ continue
+ }
+
+ name := strings.TrimSuffix(f, ".json")
+ names = append(names, name)
+ }
+
+ ginx.NewRender(c).Data(names, nil)
+}
+
+type alertRuleBuiltinImportForm struct {
+ Name string `json:"name" binding:"required"`
+ DatasourceId int64 `json:"datasource_id" binding:"required"`
+}
+
+func (rt *Router) alertRuleBuiltinImport(c *gin.Context) {
+ var f alertRuleBuiltinImportForm
+ ginx.BindJSON(c, &f)
+
+ dirpath := rt.Center.BuiltinIntegrationsDir
+ if dirpath == "" {
+ dirpath = path.Join(runner.Cwd, "etc", "alerts")
+ }
+
+ jsonfile := path.Join(dirpath, f.Name+".json")
+ if !file.IsExist(jsonfile) {
+ ginx.Bomb(http.StatusBadRequest, "%s not found", jsonfile)
+ }
+
+ var lst []models.AlertRule
+ ginx.Dangerous(file.ReadJson(jsonfile, &lst))
+
+ count := len(lst)
+ if count == 0 {
+ ginx.Bomb(http.StatusBadRequest, "builtin alerts is empty, file: %s", jsonfile)
+ }
+
+ username := c.MustGet("username").(string)
+ bgid := ginx.UrlParamInt64(c, "id")
+
+ // alert rule name -> error string
+ reterr := make(map[string]string)
+ for i := 0; i < count; i++ {
+ lst[i].Id = 0
+ lst[i].DatasourceIdsJson = []int64{f.DatasourceId}
+ lst[i].GroupId = bgid
+ lst[i].CreateBy = username
+ lst[i].UpdateBy = username
+
+ if err := lst[i].FE2DB(); err != nil {
+ reterr[lst[i].Name] = i18n.Sprintf(c.GetHeader("X-Language"), err.Error())
+ continue
+ }
+
+ if err := lst[i].Add(rt.Ctx, models.GetChannelMap(rt.Ctx)); err != nil {
+ reterr[lst[i].Name] = i18n.Sprintf(c.GetHeader("X-Language"), err.Error())
+ } else {
+ reterr[lst[i].Name] = ""
+ }
+ }
+
+ ginx.NewRender(c).Data(reterr, nil)
+}
+
+type Payload struct {
+ Cate string `json:"cate"`
+ Fname string `json:"fname"`
+ Name string `json:"name"`
+ Configs interface{} `json:"configs"`
+ Tags string `json:"tags"`
+}
+
+type BoardCate struct {
+ Name string `json:"name"`
+ IconUrl string `json:"icon_url"`
+ Boards []Payload `json:"boards"`
+ Favorite bool `json:"favorite"`
+}
+
+func (rt *Router) builtinBoardDetailGets(c *gin.Context) {
+ var payload Payload
+ ginx.BindJSON(c, &payload)
+
+ fp := rt.Center.BuiltinIntegrationsDir
+ if fp == "" {
+ fp = path.Join(runner.Cwd, "integrations")
+ }
+
+ fn := fp + "/" + payload.Cate + "/dashboards/" + payload.Fname
+ content, err := file.ReadBytes(fn)
+ ginx.Dangerous(err)
+
+ err = json.Unmarshal(content, &payload)
+ ginx.NewRender(c).Data(payload, err)
+}
+
+func (rt *Router) builtinBoardCateGets(c *gin.Context) {
+ fp := rt.Center.BuiltinIntegrationsDir
+ if fp == "" {
+ fp = path.Join(runner.Cwd, "integrations")
+ }
+
+ me := c.MustGet("user").(*models.User)
+ buildinFavoritesMap, err := models.BuiltinCateGetByUserId(rt.Ctx, me.Id)
+ if err != nil {
+ logger.Warningf("get builtin favorites fail: %v", err)
+ }
+
+ var boardCates []BoardCate
+ dirList, err := file.DirsUnder(fp)
+ ginx.Dangerous(err)
+ for _, dir := range dirList {
+ var boardCate BoardCate
+ boardCate.Name = dir
+ files, err := file.FilesUnder(fp + "/" + dir + "/dashboards")
+ ginx.Dangerous(err)
+
+ var boards []Payload
+ for _, f := range files {
+ fn := fp + "/" + dir + "/dashboards/" + f
+ content, err := file.ReadBytes(fn)
+ if err != nil {
+ logger.Warningf("add board fail: %v", err)
+ continue
+ }
+
+ var payload Payload
+ err = json.Unmarshal(content, &payload)
+ if err != nil {
+ logger.Warningf("add board:%s fail: %v", fn, err)
+ continue
+ }
+ payload.Cate = dir
+ payload.Fname = f
+ payload.Configs = ""
+ boards = append(boards, payload)
+ }
+ boardCate.Boards = boards
+
+ if _, ok := buildinFavoritesMap[dir]; ok {
+ boardCate.Favorite = true
+ }
+
+ iconFiles, _ := file.FilesUnder(fp + "/" + dir + "/icon")
+ if len(iconFiles) > 0 {
+ boardCate.IconUrl = fmt.Sprintf("/api/n9e/integrations/icon/%s/%s", dir, iconFiles[0])
+ }
+
+ boardCates = append(boardCates, boardCate)
+ }
+ ginx.NewRender(c).Data(boardCates, nil)
+}
+
+func (rt *Router) builtinBoardGets(c *gin.Context) {
+ fp := rt.Center.BuiltinIntegrationsDir
+ if fp == "" {
+ fp = path.Join(runner.Cwd, "integrations")
+ }
+
+ var fileList []string
+ dirList, err := file.DirsUnder(fp)
+ ginx.Dangerous(err)
+ for _, dir := range dirList {
+ files, err := file.FilesUnder(fp + "/" + dir + "/dashboards")
+ ginx.Dangerous(err)
+ fileList = append(fileList, files...)
+ }
+
+ names := make([]string, 0, len(fileList))
+ for _, f := range fileList {
+ if !strings.HasSuffix(f, ".json") {
+ continue
+ }
+
+ name := strings.TrimSuffix(f, ".json")
+ names = append(names, name)
+ }
+
+ ginx.NewRender(c).Data(names, nil)
+}
+
+type AlertCate struct {
+ Name string `json:"name"`
+ IconUrl string `json:"icon_url"`
+ AlertRules []models.AlertRule `json:"alert_rules"`
+ Favorite bool `json:"favorite"`
+}
+
+func (rt *Router) builtinAlertCateGets(c *gin.Context) {
+ fp := rt.Center.BuiltinIntegrationsDir
+ if fp == "" {
+ fp = path.Join(runner.Cwd, "integrations")
+ }
+
+ me := c.MustGet("user").(*models.User)
+ buildinFavoritesMap, err := models.BuiltinCateGetByUserId(rt.Ctx, me.Id)
+ if err != nil {
+ logger.Warningf("get builtin favorites fail: %v", err)
+ }
+
+ var alertCates []AlertCate
+ dirList, err := file.DirsUnder(fp)
+ ginx.Dangerous(err)
+ for _, dir := range dirList {
+ var alertCate AlertCate
+ alertCate.Name = dir
+ files, err := file.FilesUnder(fp + "/" + dir + "/alerts")
+ ginx.Dangerous(err)
+
+ var alertRules []models.AlertRule
+ for _, f := range files {
+ fn := fp + "/" + dir + "/alerts/" + f
+ content, err := file.ReadBytes(fn)
+ if err != nil {
+ logger.Warningf("add board fail: %v", err)
+ continue
+ }
+
+ var ars []models.AlertRule
+ err = json.Unmarshal(content, &ars)
+ if err != nil {
+ logger.Warningf("add board:%s fail: %v", fn, err)
+ continue
+ }
+ alertRules = append(alertRules, ars...)
+ }
+ alertCate.AlertRules = alertRules
+ iconFiles, _ := file.FilesUnder(fp + "/" + dir + "/icon")
+ if len(iconFiles) > 0 {
+ alertCate.IconUrl = fmt.Sprintf("/api/n9e/integrations/icon/%s/%s", dir, iconFiles[0])
+ }
+
+ if _, ok := buildinFavoritesMap[dir]; ok {
+ alertCate.Favorite = true
+ }
+
+ alertCates = append(alertCates, alertCate)
+ }
+ ginx.NewRender(c).Data(alertCates, nil)
+}
+
+// read the json file content
+func (rt *Router) builtinBoardGet(c *gin.Context) {
+ name := ginx.UrlParamStr(c, "name")
+ dirpath := rt.Center.BuiltinIntegrationsDir
+ if dirpath == "" {
+ dirpath = path.Join(runner.Cwd, "integrations")
+ }
+
+ dirList, err := file.DirsUnder(dirpath)
+ ginx.Dangerous(err)
+ for _, dir := range dirList {
+ jsonFile := dirpath + "/" + dir + "/dashboards/" + name + ".json"
+ if file.IsExist(jsonFile) {
+ body, err := file.ReadString(jsonFile)
+ ginx.NewRender(c).Data(body, err)
+ return
+ }
+ }
+
+ ginx.Bomb(http.StatusBadRequest, "%s not found", name)
+}
diff --git a/src/webapi/router/router_busi_group.go b/center/router/router_busi_group.go
similarity index 69%
rename from src/webapi/router/router_busi_group.go
rename to center/router/router_busi_group.go
index dddfdc8ebf83765d1d410ddf6fb2a253159e5658..fa8ffa3bd8d33138092302a01792e8a14fab52a8 100644
--- a/src/webapi/router/router_busi_group.go
+++ b/center/router/router_busi_group.go
@@ -3,12 +3,12 @@ package router
import (
"net/http"
+ "github.com/ccfos/nightingale/v6/models"
+
"github.com/gin-gonic/gin"
"github.com/toolkits/pkg/ginx"
"github.com/toolkits/pkg/logger"
"github.com/toolkits/pkg/str"
-
- "github.com/didi/nightingale/v5/src/models"
)
type busiGroupForm struct {
@@ -18,7 +18,7 @@ type busiGroupForm struct {
Members []models.BusiGroupMember `json:"members"`
}
-func busiGroupAdd(c *gin.Context) {
+func (rt *Router) busiGroupAdd(c *gin.Context) {
var f busiGroupForm
ginx.BindJSON(c, &f)
@@ -39,10 +39,10 @@ func busiGroupAdd(c *gin.Context) {
}
username := c.MustGet("username").(string)
- ginx.Dangerous(models.BusiGroupAdd(f.Name, f.LabelEnable, f.LabelValue, f.Members, username))
+ ginx.Dangerous(models.BusiGroupAdd(rt.Ctx, f.Name, f.LabelEnable, f.LabelValue, f.Members, username))
// 如果创建成功，拿着name去查，应该可以查到
- newbg, err := models.BusiGroupGet("name=?", f.Name)
+ newbg, err := models.BusiGroupGet(rt.Ctx, "name=?", f.Name)
ginx.Dangerous(err)
if newbg == nil {
@@ -53,16 +53,16 @@ func busiGroupAdd(c *gin.Context) {
ginx.NewRender(c).Data(newbg.Id, nil)
}
-func busiGroupPut(c *gin.Context) {
+func (rt *Router) busiGroupPut(c *gin.Context) {
var f busiGroupForm
ginx.BindJSON(c, &f)
username := c.MustGet("username").(string)
targetbg := c.MustGet("busi_group").(*models.BusiGroup)
- ginx.NewRender(c).Message(targetbg.Update(f.Name, f.LabelEnable, f.LabelValue, username))
+ ginx.NewRender(c).Message(targetbg.Update(rt.Ctx, f.Name, f.LabelEnable, f.LabelValue, username))
}
-func busiGroupMemberAdd(c *gin.Context) {
+func (rt *Router) busiGroupMemberAdd(c *gin.Context) {
var members []models.BusiGroupMember
ginx.BindJSON(c, &members)
@@ -75,10 +75,10 @@ func busiGroupMemberAdd(c *gin.Context) {
}
}
- ginx.NewRender(c).Message(targetbg.AddMembers(members, username))
+ ginx.NewRender(c).Message(targetbg.AddMembers(rt.Ctx, members, username))
}
-func busiGroupMemberDel(c *gin.Context) {
+func (rt *Router) busiGroupMemberDel(c *gin.Context) {
var members []models.BusiGroupMember
ginx.BindJSON(c, &members)
@@ -91,14 +91,14 @@ func busiGroupMemberDel(c *gin.Context) {
}
}
- ginx.NewRender(c).Message(targetbg.DelMembers(members, username))
+ ginx.NewRender(c).Message(targetbg.DelMembers(rt.Ctx, members, username))
}
-func busiGroupDel(c *gin.Context) {
+func (rt *Router) busiGroupDel(c *gin.Context) {
username := c.MustGet("username").(string)
targetbg := c.MustGet("busi_group").(*models.BusiGroup)
- err := targetbg.Del()
+ err := targetbg.Del(rt.Ctx)
if err != nil {
logger.Infof("busi_group_delete fail: operator=%s, group_name=%s error=%v", username, targetbg.Name, err)
} else {
@@ -109,26 +109,29 @@ func busiGroupDel(c *gin.Context) {
}
// 我是超管、或者我是业务组成员
-func busiGroupGets(c *gin.Context) {
+func (rt *Router) busiGroupGets(c *gin.Context) {
limit := ginx.QueryInt(c, "limit", defaultLimit)
query := ginx.QueryStr(c, "query", "")
all := ginx.QueryBool(c, "all", false)
me := c.MustGet("user").(*models.User)
- lst, err := me.BusiGroups(limit, query, all)
+ lst, err := me.BusiGroups(rt.Ctx, limit, query, all)
+ if len(lst) == 0 {
+ lst = []models.BusiGroup{}
+ }
ginx.NewRender(c).Data(lst, err)
}
// 这个接口只有在活跃告警页面才调用，获取各个BG的活跃告警数量
-func busiGroupAlertingsGets(c *gin.Context) {
+func (rt *Router) busiGroupAlertingsGets(c *gin.Context) {
ids := ginx.QueryStr(c, "ids", "")
- ret, err := models.AlertNumbers(str.IdsInt64(ids))
+ ret, err := models.AlertNumbers(rt.Ctx, str.IdsInt64(ids))
ginx.NewRender(c).Data(ret, err)
}
-func busiGroupGet(c *gin.Context) {
- bg := BusiGroup(ginx.UrlParamInt64(c, "id"))
- ginx.Dangerous(bg.FillUserGroups())
+func (rt *Router) busiGroupGet(c *gin.Context) {
+ bg := BusiGroup(rt.Ctx, ginx.UrlParamInt64(c, "id"))
+ ginx.Dangerous(bg.FillUserGroups(rt.Ctx))
ginx.NewRender(c).Data(bg, nil)
}
diff --git a/src/webapi/router/router_chart_share.go b/center/router/router_chart_share.go
similarity index 53%
rename from src/webapi/router/router_chart_share.go
rename to center/router/router_chart_share.go
index f874677aecc9601afdb5b61f99131d7cc8571db1..0d2c28b8335f432d4915d4e51e828a9760c3aaac 100644
--- a/src/webapi/router/router_chart_share.go
+++ b/center/router/router_chart_share.go
@@ -3,26 +3,26 @@ package router
import (
"time"
+ "github.com/ccfos/nightingale/v6/models"
+
"github.com/gin-gonic/gin"
"github.com/toolkits/pkg/ginx"
"github.com/toolkits/pkg/str"
-
- "github.com/didi/nightingale/v5/src/models"
)
-func chartShareGets(c *gin.Context) {
+func (rt *Router) chartShareGets(c *gin.Context) {
ids := ginx.QueryStr(c, "ids", "")
- lst, err := models.ChartShareGetsByIds(str.IdsInt64(ids, ","))
+ lst, err := models.ChartShareGetsByIds(rt.Ctx, str.IdsInt64(ids, ","))
ginx.NewRender(c).Data(lst, err)
}
type chartShareForm struct {
- Configs string `json:"configs"`
+ DatasourceId int64 `json:"datasource_id"`
+ Configs string `json:"configs"`
}
-func chartShareAdd(c *gin.Context) {
+func (rt *Router) chartShareAdd(c *gin.Context) {
username := c.MustGet("username").(string)
- cluster := MustGetCluster(c)
var forms []chartShareForm
ginx.BindJSON(c, &forms)
@@ -32,12 +32,12 @@ func chartShareAdd(c *gin.Context) {
for _, f := range forms {
chart := models.ChartShare{
- Cluster: cluster,
- Configs: f.Configs,
- CreateBy: username,
- CreateAt: now,
+ DatasourceId: f.DatasourceId,
+ Configs: f.Configs,
+ CreateBy: username,
+ CreateAt: now,
}
- ginx.Dangerous(chart.Add())
+ ginx.Dangerous(chart.Add(rt.Ctx))
ids = append(ids, chart.Id)
}
diff --git a/center/router/router_config.go b/center/router/router_config.go
new file mode 100644
index 0000000000000000000000000000000000000000..00633017565aaedda67aaee052b60d8634cd7713
--- /dev/null
+++ b/center/router/router_config.go
@@ -0,0 +1,64 @@
+package router
+
+import (
+ "encoding/json"
+
+ "github.com/ccfos/nightingale/v6/models"
+
+ "github.com/gin-gonic/gin"
+ "github.com/toolkits/pkg/ginx"
+)
+
+func (rt *Router) notifyChannelsGets(c *gin.Context) {
+ var labelAndKeys []models.LabelAndKey
+ cval, err := models.ConfigsGet(rt.Ctx, models.NOTIFYCHANNEL)
+ ginx.Dangerous(err)
+
+ if cval == "" {
+ ginx.NewRender(c).Data(labelAndKeys, nil)
+ return
+ }
+
+ var notifyChannels []models.NotifyChannel
+ err = json.Unmarshal([]byte(cval), ¬ifyChannels)
+ ginx.Dangerous(err)
+
+ for _, v := range notifyChannels {
+ if v.Hide {
+ continue
+ }
+ var labelAndKey models.LabelAndKey
+ labelAndKey.Label = v.Name
+ labelAndKey.Key = v.Ident
+ labelAndKeys = append(labelAndKeys, labelAndKey)
+ }
+
+ ginx.NewRender(c).Data(labelAndKeys, nil)
+}
+
+func (rt *Router) contactKeysGets(c *gin.Context) {
+ var labelAndKeys []models.LabelAndKey
+ cval, err := models.ConfigsGet(rt.Ctx, models.NOTIFYCONTACT)
+ ginx.Dangerous(err)
+
+ if cval == "" {
+ ginx.NewRender(c).Data(labelAndKeys, nil)
+ return
+ }
+
+ var notifyContacts []models.NotifyContact
+ err = json.Unmarshal([]byte(cval), ¬ifyContacts)
+ ginx.Dangerous(err)
+
+ for _, v := range notifyContacts {
+ if v.Hide {
+ continue
+ }
+ var labelAndKey models.LabelAndKey
+ labelAndKey.Label = v.Name
+ labelAndKey.Key = v.Ident
+ labelAndKeys = append(labelAndKeys, labelAndKey)
+ }
+
+ ginx.NewRender(c).Data(labelAndKeys, nil)
+}
diff --git a/src/webapi/router/router_configs.go b/center/router/router_configs.go
similarity index 51%
rename from src/webapi/router/router_configs.go
rename to center/router/router_configs.go
index 83d30478172c2b98952fbe8b851e5385e1ba14bb..0a1194777e141269e5717b9cabdb205d0ddb755e 100644
--- a/src/webapi/router/router_configs.go
+++ b/center/router/router_configs.go
@@ -1,48 +1,48 @@
package router
import (
- "github.com/didi/nightingale/v5/src/models"
+ "github.com/ccfos/nightingale/v6/models"
"github.com/gin-gonic/gin"
"github.com/toolkits/pkg/ginx"
)
-func configsGet(c *gin.Context) {
+func (rt *Router) configsGet(c *gin.Context) {
prefix := ginx.QueryStr(c, "prefix", "")
limit := ginx.QueryInt(c, "limit", 10)
- configs, err := models.ConfigsGets(prefix, limit, ginx.Offset(c, limit))
+ configs, err := models.ConfigsGets(rt.Ctx, prefix, limit, ginx.Offset(c, limit))
ginx.NewRender(c).Data(configs, err)
}
-func configGet(c *gin.Context) {
+func (rt *Router) configGet(c *gin.Context) {
id := ginx.UrlParamInt64(c, "id")
- configs, err := models.ConfigGet(id)
+ configs, err := models.ConfigGet(rt.Ctx, id)
ginx.NewRender(c).Data(configs, err)
}
-func configsDel(c *gin.Context) {
+func (rt *Router) configsDel(c *gin.Context) {
var f idsForm
ginx.BindJSON(c, &f)
- ginx.NewRender(c).Message(models.ConfigsDel(f.Ids))
+ ginx.NewRender(c).Message(models.ConfigsDel(rt.Ctx, f.Ids))
}
-func configsPut(c *gin.Context) {
+func (rt *Router) configsPut(c *gin.Context) {
var arr []models.Configs
ginx.BindJSON(c, &arr)
for i := 0; i < len(arr); i++ {
- ginx.Dangerous(arr[i].Update())
+ ginx.Dangerous(arr[i].Update(rt.Ctx))
}
ginx.NewRender(c).Message(nil)
}
-func configsPost(c *gin.Context) {
+func (rt *Router) configsPost(c *gin.Context) {
var arr []models.Configs
ginx.BindJSON(c, &arr)
for i := 0; i < len(arr); i++ {
- ginx.Dangerous(arr[i].Add())
+ ginx.Dangerous(arr[i].Add(rt.Ctx))
}
ginx.NewRender(c).Message(nil)
diff --git a/src/webapi/router/router_crypto.go b/center/router/router_crypto.go
similarity index 86%
rename from src/webapi/router/router_crypto.go
rename to center/router/router_crypto.go
index 3ecd9185248bc89f0167ff1cbc44a7a838ead1c0..9a5e0dd626570902a29de2c8500291b8621037ba 100644
--- a/src/webapi/router/router_crypto.go
+++ b/center/router/router_crypto.go
@@ -1,7 +1,8 @@
package router
import (
- "github.com/didi/nightingale/v5/src/pkg/secu"
+ "github.com/ccfos/nightingale/v6/pkg/secu"
+
"github.com/gin-gonic/gin"
"github.com/toolkits/pkg/ginx"
)
@@ -11,7 +12,7 @@ type confPropCrypto struct {
Key string `json:"key" binding:"required"`
}
-func confPropEncrypt(c *gin.Context) {
+func (rt *Router) confPropEncrypt(c *gin.Context) {
var f confPropCrypto
ginx.BindJSON(c, &f)
@@ -36,7 +37,7 @@ func confPropEncrypt(c *gin.Context) {
})
}
-func confPropDecrypt(c *gin.Context) {
+func (rt *Router) confPropDecrypt(c *gin.Context) {
var f confPropCrypto
ginx.BindJSON(c, &f)
diff --git a/center/router/router_dashboard.go b/center/router/router_dashboard.go
new file mode 100644
index 0000000000000000000000000000000000000000..51cf2da47a79a151def95a1db94fd6d8ff676c52
--- /dev/null
+++ b/center/router/router_dashboard.go
@@ -0,0 +1,19 @@
+package router
+
+type ChartPure struct {
+ Configs string `json:"configs"`
+ Weight int `json:"weight"`
+}
+
+type ChartGroupPure struct {
+ Name string `json:"name"`
+ Weight int `json:"weight"`
+ Charts []ChartPure `json:"charts"`
+}
+
+type DashboardPure struct {
+ Name string `json:"name"`
+ Tags string `json:"tags"`
+ Configs string `json:"configs"`
+ ChartGroups []ChartGroupPure `json:"chart_groups"`
+}
diff --git a/center/router/router_datasource.go b/center/router/router_datasource.go
new file mode 100644
index 0000000000000000000000000000000000000000..44a2002aff9bcabd84b9086976d6ee54bbd860aa
--- /dev/null
+++ b/center/router/router_datasource.go
@@ -0,0 +1,97 @@
+package router
+
+import (
+ "github.com/ccfos/nightingale/v6/models"
+
+ "github.com/gin-gonic/gin"
+ "github.com/toolkits/pkg/ginx"
+)
+
+func (rt *Router) pluginList(c *gin.Context) {
+ Render(c, rt.Center.Plugins, nil)
+}
+
+type listReq struct {
+ Name string `json:"name"`
+ Type string `json:"plugin_type"`
+ Category string `json:"category"`
+ Limit int `json:"limit"`
+ P int `json:"p"`
+}
+
+func (rt *Router) datasourceList(c *gin.Context) {
+ var req listReq
+ ginx.BindJSON(c, &req)
+ if req.Limit == 0 {
+ req.Limit = 10
+ }
+ if req.P == 0 {
+ req.P = 1
+ }
+
+ typ := req.Type
+ category := req.Category
+ name := req.Name
+ limit := req.Limit
+ p := req.P
+
+ list, err := models.GetDatasourcesGetsBy(rt.Ctx, typ, category, name, limit, (p-1)*limit)
+ Render(c, list, err)
+}
+
+func (rt *Router) datasourceUpsert(c *gin.Context) {
+ var req models.Datasource
+ ginx.BindJSON(c, &req)
+ username := Username(c)
+ req.UpdatedBy = username
+
+ var err error
+ var count int64
+ if req.Id == 0 {
+ req.CreatedBy = username
+ req.Status = "enabled"
+ count, err = models.GetDatasourcesCountBy(rt.Ctx, "", "", req.Name)
+ if err != nil {
+ Render(c, nil, err)
+ return
+ }
+
+ if count > 0 {
+ Render(c, nil, "name already exists")
+ return
+ }
+ err = req.Add(rt.Ctx)
+ } else {
+ err = req.Update(rt.Ctx, "name", "description", "cluster_name", "settings", "http", "auth", "status", "updated_by", "updated_at")
+ }
+
+ Render(c, nil, err)
+}
+
+func (rt *Router) datasourceGet(c *gin.Context) {
+ var req models.Datasource
+ ginx.BindJSON(c, &req)
+ err := req.Get(rt.Ctx)
+ Render(c, req, err)
+}
+
+func (rt *Router) datasourceUpdataStatus(c *gin.Context) {
+ var req models.Datasource
+ ginx.BindJSON(c, &req)
+ username := Username(c)
+ req.UpdatedBy = username
+ err := req.Update(rt.Ctx, "status", "updated_by", "updated_at")
+ Render(c, req, err)
+}
+
+func (rt *Router) datasourceDel(c *gin.Context) {
+ var ids []int64
+ ginx.BindJSON(c, &ids)
+ err := models.DatasourceDel(rt.Ctx, ids)
+ Render(c, nil, err)
+}
+
+func Username(c *gin.Context) string {
+
+ return c.MustGet("username").(string)
+}
diff --git a/center/router/router_funcs.go b/center/router/router_funcs.go
new file mode 100644
index 0000000000000000000000000000000000000000..dc439cf4a39db0b999da29ae3cb74eaf90027180
--- /dev/null
+++ b/center/router/router_funcs.go
@@ -0,0 +1,121 @@
+package router
+
+import (
+ "fmt"
+ "net/http"
+ "strconv"
+ "strings"
+
+ "github.com/ccfos/nightingale/v6/center/cconf"
+ "github.com/ccfos/nightingale/v6/models"
+ "github.com/ccfos/nightingale/v6/pkg/ctx"
+ "github.com/ccfos/nightingale/v6/pkg/ibex"
+ "github.com/gin-gonic/gin"
+
+ "github.com/toolkits/pkg/ginx"
+)
+
+const defaultLimit = 300
+
+func queryDatasourceIds(c *gin.Context) []int64 {
+ datasourceIds := ginx.QueryStr(c, "datasource_ids", "")
+ datasourceIds = strings.ReplaceAll(datasourceIds, ",", " ")
+ idsStr := strings.Fields(datasourceIds)
+ ids := make([]int64, len(idsStr))
+ for i, idStr := range idsStr {
+ id, _ := strconv.ParseInt(idStr, 10, 64)
+ ids[i] = id
+ }
+ return ids
+}
+
+type idsForm struct {
+ Ids []int64 `json:"ids"`
+}
+
+func (f idsForm) Verify() {
+ if len(f.Ids) == 0 {
+ ginx.Bomb(http.StatusBadRequest, "ids empty")
+ }
+}
+
+func User(ctx *ctx.Context, id int64) *models.User {
+ obj, err := models.UserGetById(ctx, id)
+ ginx.Dangerous(err)
+
+ if obj == nil {
+ ginx.Bomb(http.StatusNotFound, "No such user")
+ }
+
+ return obj
+}
+
+func UserGroup(ctx *ctx.Context, id int64) *models.UserGroup {
+ obj, err := models.UserGroupGetById(ctx, id)
+ ginx.Dangerous(err)
+
+ if obj == nil {
+ ginx.Bomb(http.StatusNotFound, "No such UserGroup")
+ }
+
+ return obj
+}
+
+func BusiGroup(ctx *ctx.Context, id int64) *models.BusiGroup {
+ obj, err := models.BusiGroupGetById(ctx, id)
+ ginx.Dangerous(err)
+
+ if obj == nil {
+ ginx.Bomb(http.StatusNotFound, "No such BusiGroup")
+ }
+
+ return obj
+}
+
+func Dashboard(ctx *ctx.Context, id int64) *models.Dashboard {
+ obj, err := models.DashboardGet(ctx, "id=?", id)
+ ginx.Dangerous(err)
+
+ if obj == nil {
+ ginx.Bomb(http.StatusNotFound, "No such dashboard")
+ }
+
+ return obj
+}
+
+type DoneIdsReply struct {
+ Err string `json:"err"`
+ Dat struct {
+ List []int64 `json:"list"`
+ } `json:"dat"`
+}
+
+type TaskCreateReply struct {
+ Err string `json:"err"`
+ Dat int64 `json:"dat"` // task.id
+}
+
+// return task.id, error
+func TaskCreate(v interface{}, ibexc cconf.Ibex) (int64, error) {
+ var res TaskCreateReply
+ err := ibex.New(
+ ibexc.Address,
+ ibexc.BasicAuthUser,
+ ibexc.BasicAuthPass,
+ ibexc.Timeout,
+ ).
+ Path("/ibex/v1/tasks").
+ In(v).
+ Out(&res).
+ POST()
+
+ if err != nil {
+ return 0, err
+ }
+
+ if res.Err != "" {
+ return 0, fmt.Errorf("response.err: %v", res.Err)
+ }
+
+ return res.Dat, nil
+}
diff --git a/src/webapi/router/router_login.go b/center/router/router_login.go
similarity index 64%
rename from src/webapi/router/router_login.go
rename to center/router/router_login.go
index 37aa10e15a8e0ce99810d7a131f9b46d28463a86..d960b0c452c141c8455dc7c39ea9c1da55ad5570 100644
--- a/src/webapi/router/router_login.go
+++ b/center/router/router_login.go
@@ -7,16 +7,17 @@ import (
"strings"
"time"
+ "github.com/ccfos/nightingale/v6/models"
+ "github.com/ccfos/nightingale/v6/pkg/cas"
+ "github.com/ccfos/nightingale/v6/pkg/ldapx"
+ "github.com/ccfos/nightingale/v6/pkg/oauth2x"
+ "github.com/ccfos/nightingale/v6/pkg/oidcx"
+ "github.com/pelletier/go-toml/v2"
+
"github.com/dgrijalva/jwt-go"
"github.com/gin-gonic/gin"
"github.com/toolkits/pkg/ginx"
"github.com/toolkits/pkg/logger"
-
- "github.com/didi/nightingale/v5/src/models"
- "github.com/didi/nightingale/v5/src/pkg/cas"
- "github.com/didi/nightingale/v5/src/pkg/oauth2x"
- "github.com/didi/nightingale/v5/src/pkg/oidcc"
- "github.com/didi/nightingale/v5/src/webapi/config"
)
type loginForm struct {
@@ -24,20 +25,22 @@ type loginForm struct {
Password string `json:"password" binding:"required"`
}
-func loginPost(c *gin.Context) {
+func (rt *Router) loginPost(c *gin.Context) {
var f loginForm
ginx.BindJSON(c, &f)
- user, err := models.PassLogin(f.Username, f.Password)
+ user, err := models.PassLogin(rt.Ctx, f.Username, f.Password)
if err != nil {
// pass validate fail, try ldap
- if config.C.LDAP.Enable {
- user, err = models.LdapLogin(f.Username, f.Password)
+ if rt.Center.LDAP.Enable {
+ roles := strings.Join(rt.Center.LDAP.DefaultRoles, " ")
+ user, err = models.LdapLogin(rt.Ctx, f.Username, f.Password, roles, rt.Sso.LDAP)
if err != nil {
logger.Debugf("ldap login failed: %v username: %s", err, f.Username)
ginx.NewRender(c).Message(err)
return
}
+ user.RolesLst = rt.Center.LDAP.DefaultRoles
} else {
ginx.NewRender(c).Message(err)
return
@@ -52,9 +55,9 @@ func loginPost(c *gin.Context) {
userIdentity := fmt.Sprintf("%d-%s", user.Id, user.Username)
- ts, err := createTokens(config.C.JWTAuth.SigningKey, userIdentity)
+ ts, err := rt.createTokens(rt.Center.JWTAuth.SigningKey, userIdentity)
ginx.Dangerous(err)
- ginx.Dangerous(createAuth(c.Request.Context(), userIdentity, ts))
+ ginx.Dangerous(rt.createAuth(c.Request.Context(), userIdentity, ts))
ginx.NewRender(c).Data(gin.H{
"user": user,
@@ -63,14 +66,14 @@ func loginPost(c *gin.Context) {
}, nil)
}
-func logoutPost(c *gin.Context) {
- metadata, err := extractTokenMetadata(c.Request)
+func (rt *Router) logoutPost(c *gin.Context) {
+ metadata, err := rt.extractTokenMetadata(c.Request)
if err != nil {
ginx.NewRender(c, http.StatusBadRequest).Message("failed to parse jwt token")
return
}
- delErr := deleteTokens(c.Request.Context(), metadata)
+ delErr := rt.deleteTokens(c.Request.Context(), metadata)
if delErr != nil {
ginx.NewRender(c).Message(http.StatusText(http.StatusInternalServerError))
return
@@ -83,7 +86,7 @@ type refreshForm struct {
RefreshToken string `json:"refresh_token" binding:"required"`
}
-func refreshPost(c *gin.Context) {
+func (rt *Router) refreshPost(c *gin.Context) {
var f refreshForm
ginx.BindJSON(c, &f)
@@ -92,7 +95,7 @@ func refreshPost(c *gin.Context) {
if _, ok := token.Method.(*jwt.SigningMethodHMAC); !ok {
return nil, fmt.Errorf("unexpected jwt signing method: %v", token.Header["alg"])
}
- return []byte(config.C.JWTAuth.SigningKey), nil
+ return []byte(rt.Center.JWTAuth.SigningKey), nil
})
// if there is an error, the token must have expired
@@ -125,7 +128,7 @@ func refreshPost(c *gin.Context) {
return
}
- u, err := models.UserGetById(userid)
+ u, err := models.UserGetById(rt.Ctx, userid)
if err != nil {
ginx.NewRender(c, http.StatusInternalServerError).Message("failed to query user by id")
return
@@ -138,19 +141,19 @@ func refreshPost(c *gin.Context) {
}
// Delete the previous Refresh Token
- err = deleteAuth(c.Request.Context(), refreshUuid)
+ err = rt.deleteAuth(c.Request.Context(), refreshUuid)
if err != nil {
ginx.NewRender(c, http.StatusUnauthorized).Message(http.StatusText(http.StatusInternalServerError))
return
}
// Delete previous Access Token
- deleteAuth(c.Request.Context(), strings.Split(refreshUuid, "++")[0])
+ rt.deleteAuth(c.Request.Context(), strings.Split(refreshUuid, "++")[0])
// Create new pairs of refresh and access tokens
- ts, err := createTokens(config.C.JWTAuth.SigningKey, userIdentity)
+ ts, err := rt.createTokens(rt.Center.JWTAuth.SigningKey, userIdentity)
ginx.Dangerous(err)
- ginx.Dangerous(createAuth(c.Request.Context(), userIdentity, ts))
+ ginx.Dangerous(rt.createAuth(c.Request.Context(), userIdentity, ts))
ginx.NewRender(c).Data(gin.H{
"access_token": ts.AccessToken,
@@ -162,13 +165,13 @@ func refreshPost(c *gin.Context) {
}
}
-func loginRedirect(c *gin.Context) {
+func (rt *Router) loginRedirect(c *gin.Context) {
redirect := ginx.QueryStr(c, "redirect", "/")
v, exists := c.Get("userid")
if exists {
userid := v.(int64)
- user, err := models.UserGetById(userid)
+ user, err := models.UserGetById(rt.Ctx, userid)
ginx.Dangerous(err)
if user == nil {
ginx.Bomb(200, "user not found")
@@ -180,12 +183,12 @@ func loginRedirect(c *gin.Context) {
}
}
- if !config.C.OIDC.Enable {
+ if !rt.Center.OIDC.Enable {
ginx.NewRender(c).Data("", nil)
return
}
- redirect, err := oidcc.Authorize(redirect)
+ redirect, err := rt.Sso.OIDC.Authorize(rt.Redis, redirect)
ginx.Dangerous(err)
ginx.NewRender(c).Data(redirect, err)
@@ -198,22 +201,22 @@ type CallbackOutput struct {
RefreshToken string `json:"refresh_token"`
}
-func loginCallback(c *gin.Context) {
+func (rt *Router) loginCallback(c *gin.Context) {
code := ginx.QueryStr(c, "code", "")
state := ginx.QueryStr(c, "state", "")
- ret, err := oidcc.Callback(c.Request.Context(), code, state)
+ ret, err := rt.Sso.OIDC.Callback(rt.Redis, c.Request.Context(), code, state)
if err != nil {
logger.Debugf("sso.callback() get ret %+v error %v", ret, err)
ginx.NewRender(c).Data(CallbackOutput{}, err)
return
}
- user, err := models.UserGet("username=?", ret.Username)
+ user, err := models.UserGet(rt.Ctx, "username=?", ret.Username)
ginx.Dangerous(err)
if user != nil {
- if config.C.OIDC.CoverAttributes {
+ if rt.Center.OIDC.CoverAttributes {
if ret.Nickname != "" {
user.Nickname = ret.Nickname
}
@@ -227,7 +230,7 @@ func loginCallback(c *gin.Context) {
}
user.UpdateAt = time.Now().Unix()
- user.Update("email", "nickname", "phone", "update_at")
+ user.Update(rt.Ctx, "email", "nickname", "phone", "update_at")
}
} else {
now := time.Now().Unix()
@@ -238,8 +241,8 @@ func loginCallback(c *gin.Context) {
Phone: ret.Phone,
Email: ret.Email,
Portrait: "",
- Roles: strings.Join(config.C.OIDC.DefaultRoles, " "),
- RolesLst: config.C.OIDC.DefaultRoles,
+ Roles: strings.Join(rt.Center.OIDC.DefaultRoles, " "),
+ RolesLst: rt.Center.OIDC.DefaultRoles,
Contacts: []byte("{}"),
CreateAt: now,
UpdateAt: now,
@@ -248,14 +251,14 @@ func loginCallback(c *gin.Context) {
}
// create user from oidc
- ginx.Dangerous(user.Add())
+ ginx.Dangerous(user.Add(rt.Ctx))
}
// set user login state
userIdentity := fmt.Sprintf("%d-%s", user.Id, user.Username)
- ts, err := createTokens(config.C.JWTAuth.SigningKey, userIdentity)
+ ts, err := rt.createTokens(rt.Center.JWTAuth.SigningKey, userIdentity)
ginx.Dangerous(err)
- ginx.Dangerous(createAuth(c.Request.Context(), userIdentity, ts))
+ ginx.Dangerous(rt.createAuth(c.Request.Context(), userIdentity, ts))
redirect := "/"
if ret.Redirect != "/login" {
@@ -275,13 +278,13 @@ type RedirectOutput struct {
State string `json:"state"`
}
-func loginRedirectCas(c *gin.Context) {
+func (rt *Router) loginRedirectCas(c *gin.Context) {
redirect := ginx.QueryStr(c, "redirect", "/")
v, exists := c.Get("userid")
if exists {
userid := v.(int64)
- user, err := models.UserGetById(userid)
+ user, err := models.UserGetById(rt.Ctx, userid)
ginx.Dangerous(err)
if user == nil {
ginx.Bomb(200, "user not found")
@@ -293,13 +296,13 @@ func loginRedirectCas(c *gin.Context) {
}
}
- if !config.C.CAS.Enable {
+ if !rt.Center.CAS.Enable {
logger.Error("cas is not enable")
ginx.NewRender(c).Data("", nil)
return
}
- redirect, state, err := cas.Authorize(redirect)
+ redirect, state, err := rt.Sso.CAS.Authorize(rt.Redis, redirect)
ginx.Dangerous(err)
ginx.NewRender(c).Data(RedirectOutput{
@@ -308,22 +311,22 @@ func loginRedirectCas(c *gin.Context) {
}, err)
}
-func loginCallbackCas(c *gin.Context) {
+func (rt *Router) loginCallbackCas(c *gin.Context) {
ticket := ginx.QueryStr(c, "ticket", "")
state := ginx.QueryStr(c, "state", "")
- ret, err := cas.ValidateServiceTicket(c.Request.Context(), ticket, state)
+ ret, err := rt.Sso.CAS.ValidateServiceTicket(c.Request.Context(), ticket, state, rt.Redis)
if err != nil {
logger.Errorf("ValidateServiceTicket: %s", err)
ginx.NewRender(c).Data("", err)
return
}
- user, err := models.UserGet("username=?", ret.Username)
+ user, err := models.UserGet(rt.Ctx, "username=?", ret.Username)
if err != nil {
logger.Errorf("UserGet: %s", err)
}
ginx.Dangerous(err)
if user != nil {
- if config.C.CAS.CoverAttributes {
+ if rt.Center.CAS.CoverAttributes {
if ret.Nickname != "" {
user.Nickname = ret.Nickname
}
@@ -337,7 +340,7 @@ func loginCallbackCas(c *gin.Context) {
}
user.UpdateAt = time.Now().Unix()
- ginx.Dangerous(user.Update("email", "nickname", "phone", "update_at"))
+ ginx.Dangerous(user.Update(rt.Ctx, "email", "nickname", "phone", "update_at"))
}
} else {
now := time.Now().Unix()
@@ -346,8 +349,8 @@ func loginCallbackCas(c *gin.Context) {
Password: "******",
Nickname: ret.Nickname,
Portrait: "",
- Roles: strings.Join(config.C.CAS.DefaultRoles, " "),
- RolesLst: config.C.CAS.DefaultRoles,
+ Roles: strings.Join(rt.Center.CAS.DefaultRoles, " "),
+ RolesLst: rt.Center.CAS.DefaultRoles,
Contacts: []byte("{}"),
Phone: ret.Phone,
Email: ret.Email,
@@ -357,17 +360,17 @@ func loginCallbackCas(c *gin.Context) {
UpdateBy: "CAS",
}
// create user from cas
- ginx.Dangerous(user.Add())
+ ginx.Dangerous(user.Add(rt.Ctx))
}
// set user login state
userIdentity := fmt.Sprintf("%d-%s", user.Id, user.Username)
- ts, err := createTokens(config.C.JWTAuth.SigningKey, userIdentity)
+ ts, err := rt.createTokens(rt.Center.JWTAuth.SigningKey, userIdentity)
if err != nil {
logger.Errorf("createTokens: %s", err)
}
ginx.Dangerous(err)
- ginx.Dangerous(createAuth(c.Request.Context(), userIdentity, ts))
+ ginx.Dangerous(rt.createAuth(c.Request.Context(), userIdentity, ts))
redirect := "/"
if ret.Redirect != "/login" {
@@ -381,13 +384,13 @@ func loginCallbackCas(c *gin.Context) {
}, nil)
}
-func loginRedirectOAuth(c *gin.Context) {
+func (rt *Router) loginRedirectOAuth(c *gin.Context) {
redirect := ginx.QueryStr(c, "redirect", "/")
v, exists := c.Get("userid")
if exists {
userid := v.(int64)
- user, err := models.UserGetById(userid)
+ user, err := models.UserGetById(rt.Ctx, userid)
ginx.Dangerous(err)
if user == nil {
ginx.Bomb(200, "user not found")
@@ -399,33 +402,33 @@ func loginRedirectOAuth(c *gin.Context) {
}
}
- if !config.C.OAuth.Enable {
+ if !rt.Center.OAuth.Enable {
ginx.NewRender(c).Data("", nil)
return
}
- redirect, err := oauth2x.Authorize(redirect)
+ redirect, err := rt.Sso.OAuth2.Authorize(rt.Redis, redirect)
ginx.Dangerous(err)
ginx.NewRender(c).Data(redirect, err)
}
-func loginCallbackOAuth(c *gin.Context) {
+func (rt *Router) loginCallbackOAuth(c *gin.Context) {
code := ginx.QueryStr(c, "code", "")
state := ginx.QueryStr(c, "state", "")
- ret, err := oauth2x.Callback(c.Request.Context(), code, state)
+ ret, err := rt.Sso.OAuth2.Callback(rt.Redis, c.Request.Context(), code, state)
if err != nil {
logger.Debugf("sso.callback() get ret %+v error %v", ret, err)
ginx.NewRender(c).Data(CallbackOutput{}, err)
return
}
- user, err := models.UserGet("username=?", ret.Username)
+ user, err := models.UserGet(rt.Ctx, "username=?", ret.Username)
ginx.Dangerous(err)
if user != nil {
- if config.C.OAuth.CoverAttributes {
+ if rt.Center.OAuth.CoverAttributes {
if ret.Nickname != "" {
user.Nickname = ret.Nickname
}
@@ -439,7 +442,7 @@ func loginCallbackOAuth(c *gin.Context) {
}
user.UpdateAt = time.Now().Unix()
- user.Update("email", "nickname", "phone", "update_at")
+ user.Update(rt.Ctx, "email", "nickname", "phone", "update_at")
}
} else {
now := time.Now().Unix()
@@ -450,8 +453,8 @@ func loginCallbackOAuth(c *gin.Context) {
Phone: ret.Phone,
Email: ret.Email,
Portrait: "",
- Roles: strings.Join(config.C.OAuth.DefaultRoles, " "),
- RolesLst: config.C.OAuth.DefaultRoles,
+ Roles: strings.Join(rt.Center.OAuth.DefaultRoles, " "),
+ RolesLst: rt.Center.OAuth.DefaultRoles,
Contacts: []byte("{}"),
CreateAt: now,
UpdateAt: now,
@@ -460,14 +463,14 @@ func loginCallbackOAuth(c *gin.Context) {
}
// create user from oidc
- ginx.Dangerous(user.Add())
+ ginx.Dangerous(user.Add(rt.Ctx))
}
// set user login state
userIdentity := fmt.Sprintf("%d-%s", user.Id, user.Username)
- ts, err := createTokens(config.C.JWTAuth.SigningKey, userIdentity)
+ ts, err := rt.createTokens(rt.Center.JWTAuth.SigningKey, userIdentity)
ginx.Dangerous(err)
- ginx.Dangerous(createAuth(c.Request.Context(), userIdentity, ts))
+ ginx.Dangerous(rt.createAuth(c.Request.Context(), userIdentity, ts))
redirect := "/"
if ret.Redirect != "/login" {
@@ -488,10 +491,49 @@ type SsoConfigOutput struct {
OauthDisplayName string `json:"oauthDisplayName"`
}
-func ssoConfigGet(c *gin.Context) {
+func (rt *Router) ssoConfigNameGet(c *gin.Context) {
ginx.NewRender(c).Data(SsoConfigOutput{
- OidcDisplayName: oidcc.GetDisplayName(),
- CasDisplayName: cas.GetDisplayName(),
- OauthDisplayName: oauth2x.GetDisplayName(),
+ OidcDisplayName: rt.Sso.OIDC.GetDisplayName(),
+ CasDisplayName: rt.Sso.CAS.GetDisplayName(),
+ OauthDisplayName: rt.Sso.OAuth2.GetDisplayName(),
}, nil)
}
+
+func (rt *Router) ssoConfigGets(c *gin.Context) {
+ ginx.NewRender(c).Data(models.SsoConfigGets(rt.Ctx))
+}
+
+func (rt *Router) ssoConfigUpdate(c *gin.Context) {
+ var f models.SsoConfig
+ ginx.BindJSON(c, &f)
+
+ err := f.Update(rt.Ctx)
+ ginx.Dangerous(err)
+
+ switch f.Name {
+ case "LDAP":
+ var config ldapx.Config
+ err := toml.Unmarshal([]byte(f.Content), &config)
+ ginx.Dangerous(err)
+ rt.Sso.LDAP.Reload(config)
+ case "OIDC":
+ var config oidcx.Config
+ err := toml.Unmarshal([]byte(f.Content), &config)
+ ginx.Dangerous(err)
+
+ err = rt.Sso.OIDC.Reload(config)
+ ginx.Bomb(200, "oidc init error: %v", err)
+ case "CAS":
+ var config cas.Config
+ err := toml.Unmarshal([]byte(f.Content), &config)
+ ginx.Dangerous(err)
+ rt.Sso.CAS.Reload(config)
+ case "OAuth2":
+ var config oauth2x.Config
+ err := toml.Unmarshal([]byte(f.Content), &config)
+ ginx.Dangerous(err)
+ rt.Sso.OAuth2.Reload(config)
+ }
+
+ ginx.NewRender(c).Message(nil)
+}
diff --git a/src/webapi/router/router_metric_desc.go b/center/router/router_metric_desc.go
similarity index 89%
rename from src/webapi/router/router_metric_desc.go
rename to center/router/router_metric_desc.go
index f11f45f07d9bdfc9bc786ea8560207d6a7681b73..61e918b6551e985e1496f2a64fa1d34f815bed2c 100644
--- a/src/webapi/router/router_metric_desc.go
+++ b/center/router/router_metric_desc.go
@@ -1,24 +1,24 @@
package router
import (
+ "github.com/ccfos/nightingale/v6/center/cconf"
+
"github.com/gin-gonic/gin"
"github.com/toolkits/pkg/ginx"
-
- "github.com/didi/nightingale/v5/src/webapi/config"
)
-func metricsDescGetFile(c *gin.Context) {
- c.JSON(200, config.MetricDesc)
+func (rt *Router) metricsDescGetFile(c *gin.Context) {
+ c.JSON(200, rt.Center.MetricDesc)
}
// 前端传过来一个metric数组，后端去查询有没有对应的释义，返回map
-func metricsDescGetMap(c *gin.Context) {
+func (rt *Router) metricsDescGetMap(c *gin.Context) {
var arr []string
ginx.BindJSON(c, &arr)
ret := make(map[string]string)
for _, key := range arr {
- ret[key] = config.GetMetricDesc(c.GetHeader("X-Language"), key)
+ ret[key] = cconf.GetMetricDesc(c.GetHeader("X-Language"), key)
}
ginx.NewRender(c).Data(ret, nil)
diff --git a/src/webapi/router/router_metric_view.go b/center/router/router_metric_view.go
similarity index 63%
rename from src/webapi/router/router_metric_view.go
rename to center/router/router_metric_view.go
index b0253f20e97bfdcb49cd0d043444fe1c0dc17dbc..c4442367b1f2d16f91f2a8df61381e466d13b7e1 100644
--- a/src/webapi/router/router_metric_view.go
+++ b/center/router/router_metric_view.go
@@ -3,19 +3,20 @@ package router
import (
"net/http"
- "github.com/didi/nightingale/v5/src/models"
+ "github.com/ccfos/nightingale/v6/models"
+
"github.com/gin-gonic/gin"
"github.com/toolkits/pkg/ginx"
)
// no param
-func metricViewGets(c *gin.Context) {
- lst, err := models.MetricViewGets(c.MustGet("userid"))
+func (rt *Router) metricViewGets(c *gin.Context) {
+ lst, err := models.MetricViewGets(rt.Ctx, c.MustGet("userid"))
ginx.NewRender(c).Data(lst, err)
}
// body: name, configs, cate
-func metricViewAdd(c *gin.Context) {
+func (rt *Router) metricViewAdd(c *gin.Context) {
var f models.MetricView
ginx.BindJSON(c, &f)
@@ -28,31 +29,31 @@ func metricViewAdd(c *gin.Context) {
f.Id = 0
f.CreateBy = me.Id
- ginx.Dangerous(f.Add())
+ ginx.Dangerous(f.Add(rt.Ctx))
ginx.NewRender(c).Data(f, nil)
}
// body: ids
-func metricViewDel(c *gin.Context) {
+func (rt *Router) metricViewDel(c *gin.Context) {
var f idsForm
ginx.BindJSON(c, &f)
f.Verify()
me := c.MustGet("user").(*models.User)
if me.IsAdmin() {
- ginx.NewRender(c).Message(models.MetricViewDel(f.Ids))
+ ginx.NewRender(c).Message(models.MetricViewDel(rt.Ctx, f.Ids))
} else {
- ginx.NewRender(c).Message(models.MetricViewDel(f.Ids, me.Id))
+ ginx.NewRender(c).Message(models.MetricViewDel(rt.Ctx, f.Ids, me.Id))
}
}
// body: id, name, configs, cate
-func metricViewPut(c *gin.Context) {
+func (rt *Router) metricViewPut(c *gin.Context) {
var f models.MetricView
ginx.BindJSON(c, &f)
- view, err := models.MetricViewGet("id = ?", f.Id)
+ view, err := models.MetricViewGet(rt.Ctx, "id = ?", f.Id)
ginx.Dangerous(err)
if view == nil {
@@ -71,5 +72,5 @@ func metricViewPut(c *gin.Context) {
}
}
- ginx.NewRender(c).Message(view.Update(f.Name, f.Configs, f.Cate, me.Id))
+ ginx.NewRender(c).Message(view.Update(rt.Ctx, f.Name, f.Configs, f.Cate, me.Id))
}
diff --git a/src/webapi/router/router_mute.go b/center/router/router_mute.go
similarity index 60%
rename from src/webapi/router/router_mute.go
rename to center/router/router_mute.go
index d2eb0b34c5aed53325a2618b09ac3753aadff6e7..d5ffb6499ce6e17f8b0ce2636998750c502ac1b7 100644
--- a/src/webapi/router/router_mute.go
+++ b/center/router/router_mute.go
@@ -5,29 +5,30 @@ import (
"strings"
"time"
+ "github.com/ccfos/nightingale/v6/models"
+
"github.com/gin-gonic/gin"
"github.com/toolkits/pkg/ginx"
-
- "github.com/didi/nightingale/v5/src/models"
)
// Return all, front-end search and paging
-func alertMuteGetsByBG(c *gin.Context) {
+func (rt *Router) alertMuteGetsByBG(c *gin.Context) {
bgid := ginx.UrlParamInt64(c, "id")
- lst, err := models.AlertMuteGetsByBG(bgid)
+ lst, err := models.AlertMuteGetsByBG(rt.Ctx, bgid)
+
ginx.NewRender(c).Data(lst, err)
}
-func alertMuteGets(c *gin.Context) {
+func (rt *Router) alertMuteGets(c *gin.Context) {
prods := strings.Fields(ginx.QueryStr(c, "prods", ""))
bgid := ginx.QueryInt64(c, "bgid", 0)
query := ginx.QueryStr(c, "query", "")
- lst, err := models.AlertMuteGets(prods, bgid, query)
+ lst, err := models.AlertMuteGets(rt.Ctx, prods, bgid, query)
ginx.NewRender(c).Data(lst, err)
}
-func alertMuteAdd(c *gin.Context) {
+func (rt *Router) alertMuteAdd(c *gin.Context) {
var f models.AlertMute
ginx.BindJSON(c, &f)
@@ -35,30 +36,30 @@ func alertMuteAdd(c *gin.Context) {
f.CreateBy = username
f.GroupId = ginx.UrlParamInt64(c, "id")
- ginx.NewRender(c).Message(f.Add())
+ ginx.NewRender(c).Message(f.Add(rt.Ctx))
}
-func alertMuteAddByService(c *gin.Context) {
+func (rt *Router) alertMuteAddByService(c *gin.Context) {
var f models.AlertMute
ginx.BindJSON(c, &f)
- ginx.NewRender(c).Message(f.Add())
+ ginx.NewRender(c).Message(f.Add(rt.Ctx))
}
-func alertMuteDel(c *gin.Context) {
+func (rt *Router) alertMuteDel(c *gin.Context) {
var f idsForm
ginx.BindJSON(c, &f)
f.Verify()
- ginx.NewRender(c).Message(models.AlertMuteDel(f.Ids))
+ ginx.NewRender(c).Message(models.AlertMuteDel(rt.Ctx, f.Ids))
}
-func alertMutePutByFE(c *gin.Context) {
+func (rt *Router) alertMutePutByFE(c *gin.Context) {
var f models.AlertMute
ginx.BindJSON(c, &f)
amid := ginx.UrlParamInt64(c, "amid")
- am, err := models.AlertMuteGetById(amid)
+ am, err := models.AlertMuteGetById(rt.Ctx, amid)
ginx.Dangerous(err)
if am == nil {
@@ -66,10 +67,10 @@ func alertMutePutByFE(c *gin.Context) {
return
}
- bgrwCheck(c, am.GroupId)
+ rt.bgrwCheck(c, am.GroupId)
f.UpdateBy = c.MustGet("username").(string)
- ginx.NewRender(c).Message(am.Update(f))
+ ginx.NewRender(c).Message(am.Update(rt.Ctx, f))
}
type alertMuteFieldForm struct {
@@ -77,7 +78,7 @@ type alertMuteFieldForm struct {
Fields map[string]interface{} `json:"fields"`
}
-func alertMutePutFields(c *gin.Context) {
+func (rt *Router) alertMutePutFields(c *gin.Context) {
var f alertMuteFieldForm
ginx.BindJSON(c, &f)
@@ -89,14 +90,15 @@ func alertMutePutFields(c *gin.Context) {
f.Fields["update_at"] = time.Now().Unix()
for i := 0; i < len(f.Ids); i++ {
- am, err := models.AlertMuteGetById(f.Ids[i])
+ am, err := models.AlertMuteGetById(rt.Ctx, f.Ids[i])
ginx.Dangerous(err)
if am == nil {
continue
}
- ginx.Dangerous(am.UpdateFieldsMap(f.Fields))
+ am.FE2DB()
+ ginx.Dangerous(am.UpdateFieldsMap(rt.Ctx, f.Fields))
}
ginx.NewRender(c).Message(nil)
diff --git a/src/webapi/router/router_mw.go b/center/router/router_mw.go
similarity index 63%
rename from src/webapi/router/router_mw.go
rename to center/router/router_mw.go
index 8bb8035faf35455f07430d92db89248ff904fd46..a428fc2d72f7ba563f0fafa9c0ef4bd10a20c29d 100644
--- a/src/webapi/router/router_mw.go
+++ b/center/router/router_mw.go
@@ -9,14 +9,12 @@ import (
"strings"
"time"
+ "github.com/ccfos/nightingale/v6/models"
+
"github.com/gin-gonic/gin"
"github.com/golang-jwt/jwt"
"github.com/google/uuid"
"github.com/toolkits/pkg/ginx"
-
- "github.com/didi/nightingale/v5/src/models"
- "github.com/didi/nightingale/v5/src/storage"
- "github.com/didi/nightingale/v5/src/webapi/config"
)
type AccessDetails struct {
@@ -24,14 +22,14 @@ type AccessDetails struct {
UserIdentity string
}
-func handleProxyUser(c *gin.Context) *models.User {
- headerUserNameKey := config.C.ProxyAuth.HeaderUserNameKey
+func (rt *Router) handleProxyUser(c *gin.Context) *models.User {
+ headerUserNameKey := rt.Center.ProxyAuth.HeaderUserNameKey
username := c.GetHeader(headerUserNameKey)
if username == "" {
ginx.Bomb(http.StatusUnauthorized, "unauthorized")
}
- user, err := models.UserGetByUsername(username)
+ user, err := models.UserGetByUsername(rt.Ctx, username)
if err != nil {
ginx.Bomb(http.StatusInternalServerError, err.Error())
}
@@ -41,13 +39,13 @@ func handleProxyUser(c *gin.Context) *models.User {
user = &models.User{
Username: username,
Nickname: username,
- Roles: strings.Join(config.C.ProxyAuth.DefaultRoles, " "),
+ Roles: strings.Join(rt.Center.ProxyAuth.DefaultRoles, " "),
CreateAt: now,
UpdateAt: now,
CreateBy: "system",
UpdateBy: "system",
}
- err = user.Add()
+ err = user.Add(rt.Ctx)
if err != nil {
ginx.Bomb(http.StatusInternalServerError, err.Error())
}
@@ -55,23 +53,23 @@ func handleProxyUser(c *gin.Context) *models.User {
return user
}
-func proxyAuth() gin.HandlerFunc {
+func (rt *Router) proxyAuth() gin.HandlerFunc {
return func(c *gin.Context) {
- user := handleProxyUser(c)
+ user := rt.handleProxyUser(c)
c.Set("userid", user.Id)
c.Set("username", user.Username)
c.Next()
}
}
-func jwtAuth() gin.HandlerFunc {
+func (rt *Router) jwtAuth() gin.HandlerFunc {
return func(c *gin.Context) {
- metadata, err := extractTokenMetadata(c.Request)
+ metadata, err := rt.extractTokenMetadata(c.Request)
if err != nil {
ginx.Bomb(http.StatusUnauthorized, "unauthorized")
}
- userIdentity, err := fetchAuth(c.Request.Context(), metadata.AccessUuid)
+ userIdentity, err := rt.fetchAuth(c.Request.Context(), metadata.AccessUuid)
if err != nil {
ginx.Bomb(http.StatusUnauthorized, "unauthorized")
}
@@ -94,25 +92,25 @@ func jwtAuth() gin.HandlerFunc {
}
}
-func auth() gin.HandlerFunc {
- if config.C.ProxyAuth.Enable {
- return proxyAuth()
+func (rt *Router) auth() gin.HandlerFunc {
+ if rt.Center.ProxyAuth.Enable {
+ return rt.proxyAuth()
} else {
- return jwtAuth()
+ return rt.jwtAuth()
}
}
// if proxy auth is enabled, mock jwt login/logout/refresh request
-func jwtMock() gin.HandlerFunc {
+func (rt *Router) jwtMock() gin.HandlerFunc {
return func(c *gin.Context) {
- if !config.C.ProxyAuth.Enable {
+ if !rt.Center.ProxyAuth.Enable {
c.Next()
return
}
if strings.Contains(c.FullPath(), "logout") {
ginx.Bomb(http.StatusBadRequest, "logout is not supported when proxy auth is enabled")
}
- user := handleProxyUser(c)
+ user := rt.handleProxyUser(c)
ginx.NewRender(c).Data(gin.H{
"user": user,
"access_token": "",
@@ -122,11 +120,11 @@ func jwtMock() gin.HandlerFunc {
}
}
-func user() gin.HandlerFunc {
+func (rt *Router) user() gin.HandlerFunc {
return func(c *gin.Context) {
userid := c.MustGet("userid").(int64)
- user, err := models.UserGetById(userid)
+ user, err := models.UserGetById(rt.Ctx, userid)
if err != nil {
ginx.Bomb(http.StatusUnauthorized, "unauthorized")
}
@@ -141,12 +139,12 @@ func user() gin.HandlerFunc {
}
}
-func userGroupWrite() gin.HandlerFunc {
+func (rt *Router) userGroupWrite() gin.HandlerFunc {
return func(c *gin.Context) {
me := c.MustGet("user").(*models.User)
- ug := UserGroup(ginx.UrlParamInt64(c, "id"))
+ ug := UserGroup(rt.Ctx, ginx.UrlParamInt64(c, "id"))
- can, err := me.CanModifyUserGroup(ug)
+ can, err := me.CanModifyUserGroup(rt.Ctx, ug)
ginx.Dangerous(err)
if !can {
@@ -158,12 +156,12 @@ func userGroupWrite() gin.HandlerFunc {
}
}
-func bgro() gin.HandlerFunc {
+func (rt *Router) bgro() gin.HandlerFunc {
return func(c *gin.Context) {
me := c.MustGet("user").(*models.User)
- bg := BusiGroup(ginx.UrlParamInt64(c, "id"))
+ bg := BusiGroup(rt.Ctx, ginx.UrlParamInt64(c, "id"))
- can, err := me.CanDoBusiGroup(bg)
+ can, err := me.CanDoBusiGroup(rt.Ctx, bg)
ginx.Dangerous(err)
if !can {
@@ -176,12 +174,12 @@ func bgro() gin.HandlerFunc {
}
// bgrw 逐步要被干掉，不安全
-func bgrw() gin.HandlerFunc {
+func (rt *Router) bgrw() gin.HandlerFunc {
return func(c *gin.Context) {
me := c.MustGet("user").(*models.User)
- bg := BusiGroup(ginx.UrlParamInt64(c, "id"))
+ bg := BusiGroup(rt.Ctx, ginx.UrlParamInt64(c, "id"))
- can, err := me.CanDoBusiGroup(bg, "rw")
+ can, err := me.CanDoBusiGroup(rt.Ctx, bg, "rw")
ginx.Dangerous(err)
if !can {
@@ -194,11 +192,11 @@ func bgrw() gin.HandlerFunc {
}
// bgrwCheck 要逐渐替换掉bgrw方法，更安全
-func bgrwCheck(c *gin.Context, bgid int64) {
+func (rt *Router) bgrwCheck(c *gin.Context, bgid int64) {
me := c.MustGet("user").(*models.User)
- bg := BusiGroup(bgid)
+ bg := BusiGroup(rt.Ctx, bgid)
- can, err := me.CanDoBusiGroup(bg, "rw")
+ can, err := me.CanDoBusiGroup(rt.Ctx, bg, "rw")
ginx.Dangerous(err)
if !can {
@@ -208,7 +206,7 @@ func bgrwCheck(c *gin.Context, bgid int64) {
c.Set("busi_group", bg)
}
-func bgrwChecks(c *gin.Context, bgids []int64) {
+func (rt *Router) bgrwChecks(c *gin.Context, bgids []int64) {
set := make(map[int64]struct{})
for i := 0; i < len(bgids); i++ {
@@ -216,16 +214,16 @@ func bgrwChecks(c *gin.Context, bgids []int64) {
continue
}
- bgrwCheck(c, bgids[i])
+ rt.bgrwCheck(c, bgids[i])
set[bgids[i]] = struct{}{}
}
}
-func bgroCheck(c *gin.Context, bgid int64) {
+func (rt *Router) bgroCheck(c *gin.Context, bgid int64) {
me := c.MustGet("user").(*models.User)
- bg := BusiGroup(bgid)
+ bg := BusiGroup(rt.Ctx, bgid)
- can, err := me.CanDoBusiGroup(bg)
+ can, err := me.CanDoBusiGroup(rt.Ctx, bg)
ginx.Dangerous(err)
if !can {
@@ -235,11 +233,11 @@ func bgroCheck(c *gin.Context, bgid int64) {
c.Set("busi_group", bg)
}
-func perm(operation string) gin.HandlerFunc {
+func (rt *Router) perm(operation string) gin.HandlerFunc {
return func(c *gin.Context) {
me := c.MustGet("user").(*models.User)
- can, err := me.CheckPerm(operation)
+ can, err := me.CheckPerm(rt.Ctx, operation)
ginx.Dangerous(err)
if !can {
@@ -250,11 +248,11 @@ func perm(operation string) gin.HandlerFunc {
}
}
-func admin() gin.HandlerFunc {
+func (rt *Router) admin() gin.HandlerFunc {
return func(c *gin.Context) {
userid := c.MustGet("userid").(int64)
- user, err := models.UserGetById(userid)
+ user, err := models.UserGetById(rt.Ctx, userid)
if err != nil {
ginx.Bomb(http.StatusUnauthorized, "unauthorized")
}
@@ -281,8 +279,8 @@ func admin() gin.HandlerFunc {
}
}
-func extractTokenMetadata(r *http.Request) (*AccessDetails, error) {
- token, err := verifyToken(config.C.JWTAuth.SigningKey, extractToken(r))
+func (rt *Router) extractTokenMetadata(r *http.Request) (*AccessDetails, error) {
+ token, err := rt.verifyToken(rt.Center.JWTAuth.SigningKey, rt.extractToken(r))
if err != nil {
return nil, err
}
@@ -303,7 +301,7 @@ func extractTokenMetadata(r *http.Request) (*AccessDetails, error) {
return nil, err
}
-func extractToken(r *http.Request) string {
+func (rt *Router) extractToken(r *http.Request) string {
tok := r.Header.Get("Authorization")
if len(tok) > 6 && strings.ToUpper(tok[0:7]) == "BEARER " {
@@ -313,17 +311,17 @@ func extractToken(r *http.Request) string {
return ""
}
-func createAuth(ctx context.Context, userIdentity string, td *TokenDetails) error {
+func (rt *Router) createAuth(ctx context.Context, userIdentity string, td *TokenDetails) error {
at := time.Unix(td.AtExpires, 0)
- rt := time.Unix(td.RtExpires, 0)
+ rte := time.Unix(td.RtExpires, 0)
now := time.Now()
- errAccess := storage.Redis.Set(ctx, wrapJwtKey(td.AccessUuid), userIdentity, at.Sub(now)).Err()
+ errAccess := rt.Redis.Set(ctx, rt.wrapJwtKey(td.AccessUuid), userIdentity, at.Sub(now)).Err()
if errAccess != nil {
return errAccess
}
- errRefresh := storage.Redis.Set(ctx, wrapJwtKey(td.RefreshUuid), userIdentity, rt.Sub(now)).Err()
+ errRefresh := rt.Redis.Set(ctx, rt.wrapJwtKey(td.RefreshUuid), userIdentity, rte.Sub(now)).Err()
if errRefresh != nil {
return errRefresh
}
@@ -331,26 +329,26 @@ func createAuth(ctx context.Context, userIdentity string, td *TokenDetails) erro
return nil
}
-func fetchAuth(ctx context.Context, givenUuid string) (string, error) {
- return storage.Redis.Get(ctx, wrapJwtKey(givenUuid)).Result()
+func (rt *Router) fetchAuth(ctx context.Context, givenUuid string) (string, error) {
+ return rt.Redis.Get(ctx, rt.wrapJwtKey(givenUuid)).Result()
}
-func deleteAuth(ctx context.Context, givenUuid string) error {
- return storage.Redis.Del(ctx, wrapJwtKey(givenUuid)).Err()
+func (rt *Router) deleteAuth(ctx context.Context, givenUuid string) error {
+ return rt.Redis.Del(ctx, rt.wrapJwtKey(givenUuid)).Err()
}
-func deleteTokens(ctx context.Context, authD *AccessDetails) error {
+func (rt *Router) deleteTokens(ctx context.Context, authD *AccessDetails) error {
// get the refresh uuid
refreshUuid := authD.AccessUuid + "++" + authD.UserIdentity
// delete access token
- err := storage.Redis.Del(ctx, wrapJwtKey(authD.AccessUuid)).Err()
+ err := rt.Redis.Del(ctx, rt.wrapJwtKey(authD.AccessUuid)).Err()
if err != nil {
return err
}
// delete refresh token
- err = storage.Redis.Del(ctx, wrapJwtKey(refreshUuid)).Err()
+ err = rt.Redis.Del(ctx, rt.wrapJwtKey(refreshUuid)).Err()
if err != nil {
return err
}
@@ -358,8 +356,8 @@ func deleteTokens(ctx context.Context, authD *AccessDetails) error {
return nil
}
-func wrapJwtKey(key string) string {
- return config.C.JWTAuth.RedisKeyPrefix + key
+func (rt *Router) wrapJwtKey(key string) string {
+ return rt.Center.JWTAuth.RedisKeyPrefix + key
}
type TokenDetails struct {
@@ -371,12 +369,12 @@ type TokenDetails struct {
RtExpires int64
}
-func createTokens(signingKey, userIdentity string) (*TokenDetails, error) {
+func (rt *Router) createTokens(signingKey, userIdentity string) (*TokenDetails, error) {
td := &TokenDetails{}
- td.AtExpires = time.Now().Add(time.Minute * time.Duration(config.C.JWTAuth.AccessExpired)).Unix()
+ td.AtExpires = time.Now().Add(time.Minute * time.Duration(rt.Center.JWTAuth.AccessExpired)).Unix()
td.AccessUuid = uuid.NewString()
- td.RtExpires = time.Now().Add(time.Minute * time.Duration(config.C.JWTAuth.RefreshExpired)).Unix()
+ td.RtExpires = time.Now().Add(time.Minute * time.Duration(rt.Center.JWTAuth.RefreshExpired)).Unix()
td.RefreshUuid = td.AccessUuid + "++" + userIdentity
var err error
@@ -397,8 +395,8 @@ func createTokens(signingKey, userIdentity string) (*TokenDetails, error) {
rtClaims["refresh_uuid"] = td.RefreshUuid
rtClaims["user_identity"] = userIdentity
rtClaims["exp"] = td.RtExpires
- rt := jwt.NewWithClaims(jwt.SigningMethodHS256, rtClaims)
- td.RefreshToken, err = rt.SignedString([]byte(signingKey))
+ jrt := jwt.NewWithClaims(jwt.SigningMethodHS256, rtClaims)
+ td.RefreshToken, err = jrt.SignedString([]byte(signingKey))
if err != nil {
return nil, err
}
@@ -406,7 +404,7 @@ func createTokens(signingKey, userIdentity string) (*TokenDetails, error) {
return td, nil
}
-func verifyToken(signingKey, tokenString string) (*jwt.Token, error) {
+func (rt *Router) verifyToken(signingKey, tokenString string) (*jwt.Token, error) {
if tokenString == "" {
return nil, fmt.Errorf("bearer token not found")
}
diff --git a/center/router/router_notify_config.go b/center/router/router_notify_config.go
new file mode 100644
index 0000000000000000000000000000000000000000..595a77a61527720f01aead551814d7e0b9cf7b07
--- /dev/null
+++ b/center/router/router_notify_config.go
@@ -0,0 +1,135 @@
+package router
+
+import (
+ "encoding/json"
+
+ "github.com/ccfos/nightingale/v6/models"
+
+ "github.com/gin-gonic/gin"
+ "github.com/toolkits/pkg/ginx"
+)
+
+func (rt *Router) webhookGets(c *gin.Context) {
+ var webhooks []models.Webhook
+ cval, err := models.ConfigsGet(rt.Ctx, models.WEBHOOKKEY)
+ ginx.Dangerous(err)
+ if cval == "" {
+ ginx.NewRender(c).Data(webhooks, nil)
+ return
+ }
+
+ err = json.Unmarshal([]byte(cval), &webhooks)
+ ginx.NewRender(c).Data(webhooks, err)
+}
+
+func (rt *Router) webhookPuts(c *gin.Context) {
+ var webhooks []models.Webhook
+ ginx.BindJSON(c, &webhooks)
+ for i := 0; i < len(webhooks); i++ {
+ for k, v := range webhooks[i].HeaderMap {
+ webhooks[i].Headers = append(webhooks[i].Headers, k)
+ webhooks[i].Headers = append(webhooks[i].Headers, v)
+ }
+ }
+
+ data, err := json.Marshal(webhooks)
+ ginx.Dangerous(err)
+
+ ginx.NewRender(c).Message(models.ConfigsSet(rt.Ctx, models.WEBHOOKKEY, string(data)))
+}
+
+func (rt *Router) notifyScriptGet(c *gin.Context) {
+ var notifyScript models.NotifyScript
+ cval, err := models.ConfigsGet(rt.Ctx, models.NOTIFYSCRIPT)
+ ginx.Dangerous(err)
+
+ if cval == "" {
+ ginx.NewRender(c).Data(notifyScript, nil)
+ return
+ }
+
+ err = json.Unmarshal([]byte(cval), ¬ifyScript)
+ ginx.NewRender(c).Data(notifyScript, err)
+}
+
+func (rt *Router) notifyScriptPut(c *gin.Context) {
+ var notifyScript models.NotifyScript
+ ginx.BindJSON(c, ¬ifyScript)
+
+ data, err := json.Marshal(notifyScript)
+ ginx.Dangerous(err)
+
+ ginx.NewRender(c).Message(models.ConfigsSet(rt.Ctx, models.NOTIFYSCRIPT, string(data)))
+}
+
+func (rt *Router) notifyChannelGets(c *gin.Context) {
+ var notifyChannels []models.NotifyChannel
+ cval, err := models.ConfigsGet(rt.Ctx, models.NOTIFYCHANNEL)
+ ginx.Dangerous(err)
+ if cval == "" {
+ ginx.NewRender(c).Data(notifyChannels, nil)
+ return
+ }
+
+ err = json.Unmarshal([]byte(cval), ¬ifyChannels)
+ ginx.NewRender(c).Data(notifyChannels, err)
+}
+
+func (rt *Router) notifyChannelPuts(c *gin.Context) {
+ var notifyChannels []models.NotifyChannel
+ ginx.BindJSON(c, ¬ifyChannels)
+
+ channels := []string{models.Dingtalk, models.Wecom, models.Feishu, models.Mm, models.Telegram, models.Email}
+
+ m := make(map[string]struct{})
+ for _, v := range notifyChannels {
+ m[v.Ident] = struct{}{}
+ }
+
+ for _, v := range channels {
+ if _, ok := m[v]; !ok {
+ ginx.Bomb(200, "channel %s ident can not modify", v)
+ }
+ }
+
+ data, err := json.Marshal(notifyChannels)
+ ginx.Dangerous(err)
+
+ ginx.NewRender(c).Message(models.ConfigsSet(rt.Ctx, models.NOTIFYCHANNEL, string(data)))
+}
+
+func (rt *Router) notifyContactGets(c *gin.Context) {
+ var notifyContacts []models.NotifyContact
+ cval, err := models.ConfigsGet(rt.Ctx, models.NOTIFYCONTACT)
+ ginx.Dangerous(err)
+ if cval == "" {
+ ginx.NewRender(c).Data(notifyContacts, nil)
+ return
+ }
+
+ err = json.Unmarshal([]byte(cval), ¬ifyContacts)
+ ginx.NewRender(c).Data(notifyContacts, err)
+}
+
+func (rt *Router) notifyContactPuts(c *gin.Context) {
+ var notifyContacts []models.NotifyContact
+ ginx.BindJSON(c, ¬ifyContacts)
+
+ keys := []string{models.DingtalkKey, models.WecomKey, models.FeishuKey, models.MmKey, models.TelegramKey}
+
+ m := make(map[string]struct{})
+ for _, v := range notifyContacts {
+ m[v.Ident] = struct{}{}
+ }
+
+ for _, v := range keys {
+ if _, ok := m[v]; !ok {
+ ginx.Bomb(200, "contact %s ident can not modify", v)
+ }
+ }
+
+ data, err := json.Marshal(notifyContacts)
+ ginx.Dangerous(err)
+
+ ginx.NewRender(c).Message(models.ConfigsSet(rt.Ctx, models.NOTIFYCONTACT, string(data)))
+}
diff --git a/center/router/router_notify_tpl.go b/center/router/router_notify_tpl.go
new file mode 100644
index 0000000000000000000000000000000000000000..09c3f5421abd5e53ba45d40ecabee6267f777c9a
--- /dev/null
+++ b/center/router/router_notify_tpl.go
@@ -0,0 +1,63 @@
+package router
+
+import (
+ "bytes"
+ "encoding/json"
+ "html/template"
+
+ "github.com/ccfos/nightingale/v6/models"
+ "github.com/ccfos/nightingale/v6/pkg/tplx"
+ "github.com/gin-gonic/gin"
+ "github.com/toolkits/pkg/file"
+ "github.com/toolkits/pkg/ginx"
+)
+
+func (rt *Router) notifyTplGets(c *gin.Context) {
+ lst, err := models.NotifyTplGets(rt.Ctx)
+
+ ginx.NewRender(c).Data(lst, err)
+}
+
+func (rt *Router) notifyTplUpdateContent(c *gin.Context) {
+ var f models.NotifyTpl
+ ginx.BindJSON(c, &f)
+
+ ginx.NewRender(c).Message(f.UpdateContent(rt.Ctx))
+}
+
+func (rt *Router) notifyTplUpdate(c *gin.Context) {
+ var f models.NotifyTpl
+ ginx.BindJSON(c, &f)
+
+ ginx.NewRender(c).Message(f.Update(rt.Ctx))
+}
+
+func (rt *Router) notifyTplPreview(c *gin.Context) {
+ b, err := file.ToBytes("./etc/event.json")
+ if err != nil {
+ ginx.NewRender(c).Message(err.Error())
+ return
+ }
+ var event models.AlertCurEvent
+ err = json.Unmarshal(b, &event)
+ if err != nil {
+ ginx.NewRender(c).Message(err.Error())
+ return
+ }
+
+ var f models.NotifyTpl
+ ginx.BindJSON(c, &f)
+
+ tpl, err := template.New(f.Channel).Funcs(tplx.TemplateFuncMap).Parse(f.Content)
+ ginx.Dangerous(err)
+
+ var body bytes.Buffer
+ var ret string
+ if err := tpl.Execute(&body, event); err != nil {
+ ret = err.Error()
+ } else {
+ ret = body.String()
+ }
+
+ ginx.NewRender(c).Data(ret, nil)
+}
diff --git a/center/router/router_proxy.go b/center/router/router_proxy.go
new file mode 100644
index 0000000000000000000000000000000000000000..3f7fc240a5423c91a8e5667fd9f9edda31fbd591
--- /dev/null
+++ b/center/router/router_proxy.go
@@ -0,0 +1,129 @@
+package router
+
+import (
+ "context"
+ "net"
+ "net/http"
+ "net/http/httputil"
+ "net/url"
+ "strings"
+ "time"
+
+ pkgprom "github.com/ccfos/nightingale/v6/pkg/prom"
+ "github.com/gin-gonic/gin"
+ "github.com/prometheus/common/model"
+ "github.com/toolkits/pkg/ginx"
+)
+
+type queryFormItem struct {
+ Start int64 `json:"start" binding:"required"`
+ End int64 `json:"end" binding:"required"`
+ Step int64 `json:"step" binding:"required"`
+ Query string `json:"query" binding:"required"`
+}
+
+type batchQueryForm struct {
+ DatasourceId int64 `json:"datasource_id" binding:"required"`
+ Queries []queryFormItem `json:"queries" binding:"required"`
+}
+
+func (rt *Router) promBatchQueryRange(c *gin.Context) {
+ var f batchQueryForm
+ ginx.Dangerous(c.BindJSON(&f))
+
+ cli := rt.PromClients.GetCli(f.DatasourceId)
+
+ var lst []model.Value
+
+ for _, item := range f.Queries {
+ r := pkgprom.Range{
+ Start: time.Unix(item.Start, 0),
+ End: time.Unix(item.End, 0),
+ Step: time.Duration(item.Step) * time.Second,
+ }
+
+ resp, _, err := cli.QueryRange(context.Background(), item.Query, r)
+ ginx.Dangerous(err)
+
+ lst = append(lst, resp)
+ }
+
+ ginx.NewRender(c).Data(lst, nil)
+}
+
+func (rt *Router) dsProxy(c *gin.Context) {
+ dsId := ginx.UrlParamInt64(c, "id")
+ ds := rt.DatasourceCache.GetBId(dsId)
+
+ if ds == nil {
+ c.String(http.StatusBadRequest, "no such datasource")
+ return
+ }
+
+ target, err := url.Parse(ds.HTTPJson.Url)
+ if err != nil {
+ c.String(http.StatusInternalServerError, "invalid url: %s", ds.HTTPJson.Url)
+ return
+ }
+
+ director := func(req *http.Request) {
+ req.URL.Scheme = target.Scheme
+ req.URL.Host = target.Host
+ req.Host = target.Host
+
+ req.Header.Set("Host", target.Host)
+
+ // fe request e.g. /api/n9e/proxy/:id/*
+ arr := strings.Split(req.URL.Path, "/")
+ if len(arr) < 6 {
+ c.String(http.StatusBadRequest, "invalid url path")
+ return
+ }
+
+ req.URL.Path = strings.TrimRight(target.Path, "/") + "/" + strings.Join(arr[5:], "/")
+ if target.RawQuery == "" || req.URL.RawQuery == "" {
+ req.URL.RawQuery = target.RawQuery + req.URL.RawQuery
+ } else {
+ req.URL.RawQuery = target.RawQuery + "&" + req.URL.RawQuery
+ }
+
+ if _, ok := req.Header["User-Agent"]; !ok {
+ req.Header.Set("User-Agent", "")
+ }
+
+ if ds.AuthJson.BasicAuthUser != "" {
+ req.SetBasicAuth(ds.AuthJson.BasicAuthUser, ds.AuthJson.BasicAuthPassword)
+ }
+
+ headerCount := len(ds.HTTPJson.Headers)
+ if headerCount > 0 {
+ for key, value := range ds.HTTPJson.Headers {
+ req.Header.Set(key, value)
+ if key == "Host" {
+ req.Host = value
+ }
+ }
+ }
+ }
+
+ errFunc := func(w http.ResponseWriter, r *http.Request, err error) {
+ http.Error(w, err.Error(), http.StatusBadGateway)
+ }
+
+ transport := &http.Transport{
+ Proxy: http.ProxyFromEnvironment,
+ DialContext: (&net.Dialer{
+ Timeout: time.Duration(ds.HTTPJson.DialTimeout) * time.Millisecond,
+ }).DialContext,
+ ResponseHeaderTimeout: time.Duration(ds.HTTPJson.Timeout) * time.Millisecond,
+ MaxIdleConnsPerHost: ds.HTTPJson.MaxIdleConnsPerHost,
+ }
+
+ proxy := &httputil.ReverseProxy{
+ Director: director,
+ Transport: transport,
+ ErrorHandler: errFunc,
+ }
+
+ proxy.ServeHTTP(c.Writer, c.Request)
+}
diff --git a/src/webapi/router/router_recording_rule.go b/center/router/router_recording_rule.go
similarity index 66%
rename from src/webapi/router/router_recording_rule.go
rename to center/router/router_recording_rule.go
index 5c8729af102fc6e326ea7f4d65bc237b2ec2fad5..66ce3950b805f2dc581354d16f9794780c887f3e 100644
--- a/src/webapi/router/router_recording_rule.go
+++ b/center/router/router_recording_rule.go
@@ -4,21 +4,22 @@ import (
"net/http"
"time"
- "github.com/didi/nightingale/v5/src/models"
+ "github.com/ccfos/nightingale/v6/models"
+
"github.com/gin-gonic/gin"
"github.com/toolkits/pkg/ginx"
)
-func recordingRuleGets(c *gin.Context) {
+func (rt *Router) recordingRuleGets(c *gin.Context) {
busiGroupId := ginx.UrlParamInt64(c, "id")
- ars, err := models.RecordingRuleGets(busiGroupId)
+ ars, err := models.RecordingRuleGets(rt.Ctx, busiGroupId)
ginx.NewRender(c).Data(ars, err)
}
-func recordingRuleGet(c *gin.Context) {
+func (rt *Router) recordingRuleGet(c *gin.Context) {
rrid := ginx.UrlParamInt64(c, "rrid")
- ar, err := models.RecordingRuleGetById(rrid)
+ ar, err := models.RecordingRuleGetById(rt.Ctx, rrid)
ginx.Dangerous(err)
if ar == nil {
@@ -29,7 +30,7 @@ func recordingRuleGet(c *gin.Context) {
ginx.NewRender(c).Data(ar, err)
}
-func recordingRuleAddByFE(c *gin.Context) {
+func (rt *Router) recordingRuleAddByFE(c *gin.Context) {
username := c.MustGet("username").(string)
var lst []models.RecordingRule
@@ -49,7 +50,7 @@ func recordingRuleAddByFE(c *gin.Context) {
lst[i].UpdateBy = username
lst[i].FE2DB()
- if err := lst[i].Add(); err != nil {
+ if err := lst[i].Add(rt.Ctx); err != nil {
reterr[lst[i].Name] = err.Error()
} else {
reterr[lst[i].Name] = ""
@@ -58,12 +59,12 @@ func recordingRuleAddByFE(c *gin.Context) {
ginx.NewRender(c).Data(reterr, nil)
}
-func recordingRulePutByFE(c *gin.Context) {
+func (rt *Router) recordingRulePutByFE(c *gin.Context) {
var f models.RecordingRule
ginx.BindJSON(c, &f)
rrid := ginx.UrlParamInt64(c, "rrid")
- ar, err := models.RecordingRuleGetById(rrid)
+ ar, err := models.RecordingRuleGetById(rt.Ctx, rrid)
ginx.Dangerous(err)
if ar == nil {
@@ -71,19 +72,19 @@ func recordingRulePutByFE(c *gin.Context) {
return
}
- bgrwCheck(c, ar.GroupId)
+ rt.bgrwCheck(c, ar.GroupId)
f.UpdateBy = c.MustGet("username").(string)
- ginx.NewRender(c).Message(ar.Update(f))
+ ginx.NewRender(c).Message(ar.Update(rt.Ctx, f))
}
-func recordingRuleDel(c *gin.Context) {
+func (rt *Router) recordingRuleDel(c *gin.Context) {
var f idsForm
ginx.BindJSON(c, &f)
f.Verify()
- ginx.NewRender(c).Message(models.RecordingRuleDels(f.Ids, ginx.UrlParamInt64(c, "id")))
+ ginx.NewRender(c).Message(models.RecordingRuleDels(rt.Ctx, f.Ids, ginx.UrlParamInt64(c, "id")))
}
@@ -92,7 +93,7 @@ type recordRuleFieldForm struct {
Fields map[string]interface{} `json:"fields"`
}
-func recordingRulePutFields(c *gin.Context) {
+func (rt *Router) recordingRulePutFields(c *gin.Context) {
var f recordRuleFieldForm
ginx.BindJSON(c, &f)
@@ -104,14 +105,14 @@ func recordingRulePutFields(c *gin.Context) {
f.Fields["update_at"] = time.Now().Unix()
for i := 0; i < len(f.Ids); i++ {
- ar, err := models.RecordingRuleGetById(f.Ids[i])
+ ar, err := models.RecordingRuleGetById(rt.Ctx, f.Ids[i])
ginx.Dangerous(err)
if ar == nil {
continue
}
- ginx.Dangerous(ar.UpdateFieldsMap(f.Fields))
+ ginx.Dangerous(ar.UpdateFieldsMap(rt.Ctx, f.Fields))
}
ginx.NewRender(c).Message(nil)
diff --git a/center/router/router_role.go b/center/router/router_role.go
new file mode 100644
index 0000000000000000000000000000000000000000..75eaa2ef862b019f2e5fee5317350220540ad4d3
--- /dev/null
+++ b/center/router/router_role.go
@@ -0,0 +1,85 @@
+package router
+
+import (
+ "net/http"
+ "strings"
+
+ "github.com/ccfos/nightingale/v6/models"
+
+ "github.com/gin-gonic/gin"
+ "github.com/toolkits/pkg/ginx"
+)
+
+func (rt *Router) rolesGets(c *gin.Context) {
+ lst, err := models.RoleGetsAll(rt.Ctx)
+ ginx.NewRender(c).Data(lst, err)
+}
+
+func (rt *Router) permsGets(c *gin.Context) {
+ user := c.MustGet("user").(*models.User)
+ lst, err := models.OperationsOfRole(rt.Ctx, strings.Fields(user.Roles))
+ ginx.NewRender(c).Data(lst, err)
+}
+
+// 创建角色
+func (rt *Router) roleAdd(c *gin.Context) {
+ var f models.Role
+ ginx.BindJSON(c, &f)
+
+ err := f.Add(rt.Ctx)
+ ginx.NewRender(c).Message(err)
+}
+
+// 更新角色
+func (rt *Router) rolePut(c *gin.Context) {
+ var f models.Role
+ ginx.BindJSON(c, &f)
+ oldRule, err := models.RoleGet(rt.Ctx, "id=?", f.Id)
+ ginx.Dangerous(err)
+
+ if oldRule == nil {
+ ginx.Bomb(http.StatusOK, "role not found")
+ }
+
+ if oldRule.Name == "Admin" {
+ ginx.Bomb(http.StatusOK, "admin role can not be modified")
+ }
+
+ if oldRule.Name != f.Name {
+ // name changed, check duplication
+ num, err := models.RoleCount(rt.Ctx, "name=? and id<>?", f.Name, oldRule.Id)
+ ginx.Dangerous(err)
+
+ if num > 0 {
+ ginx.Bomb(http.StatusOK, "role name already exists")
+ }
+ }
+
+ oldRule.Name = f.Name
+ oldRule.Note = f.Note
+
+ ginx.NewRender(c).Message(oldRule.Update(rt.Ctx, "name", "note"))
+}
+
+func (rt *Router) roleDel(c *gin.Context) {
+ id := ginx.UrlParamInt64(c, "id")
+ target, err := models.RoleGet(rt.Ctx, "id=?", id)
+ ginx.Dangerous(err)
+
+ if target.Name == "Admin" {
+ ginx.Bomb(http.StatusOK, "admin role can not be modified")
+ }
+
+ if target == nil {
+ ginx.NewRender(c).Message(nil)
+ return
+ }
+
+ ginx.NewRender(c).Message(target.Del(rt.Ctx))
+}
+
+// 角色列表
+func (rt *Router) roleGets(c *gin.Context) {
+ lst, err := models.RoleGetsAll(rt.Ctx)
+ ginx.NewRender(c).Data(lst, err)
+}
diff --git a/center/router/router_role_operation.go b/center/router/router_role_operation.go
new file mode 100644
index 0000000000000000000000000000000000000000..e6d1c4c213c4d250980cbcabad684ccb9e21455f
--- /dev/null
+++ b/center/router/router_role_operation.go
@@ -0,0 +1,43 @@
+package router
+
+import (
+ "net/http"
+
+ "github.com/ccfos/nightingale/v6/models"
+ "github.com/gin-gonic/gin"
+ "github.com/toolkits/pkg/ginx"
+)
+
+func (rt *Router) operationOfRole(c *gin.Context) {
+ id := ginx.UrlParamInt64(c, "id")
+ role, err := models.RoleGet(rt.Ctx, "id=?", id)
+ ginx.Dangerous(err)
+ if role == nil {
+ ginx.Bomb(http.StatusOK, "role not found")
+ }
+
+ ops, err := models.OperationsOfRole(rt.Ctx, []string{role.Name})
+ ginx.NewRender(c).Data(ops, err)
+}
+
+func (rt *Router) roleBindOperation(c *gin.Context) {
+ id := ginx.UrlParamInt64(c, "id")
+ role, err := models.RoleGet(rt.Ctx, "id=?", id)
+ ginx.Dangerous(err)
+ if role == nil {
+ ginx.Bomb(http.StatusOK, "role not found")
+ }
+
+ if role.Name == "Admin" {
+ ginx.Bomb(http.StatusOK, "admin role can not be modified")
+ }
+
+ var ops []string
+ ginx.BindJSON(c, &ops)
+
+ ginx.NewRender(c).Message(models.RoleOperationBind(rt.Ctx, role.Name, ops))
+}
+
+func (rt *Router) operations(c *gin.Context) {
+ ginx.NewRender(c).Data(rt.Operations.Ops, nil)
+}
diff --git a/src/webapi/router/router_self.go b/center/router/router_self.go
similarity index 71%
rename from src/webapi/router/router_self.go
rename to center/router/router_self.go
index 22fb9e1c6c08f95c72e8bcfc49f397b6219a3e7f..1eeeeeda7f0dbbd8f2ed8bd3b367a95a4a09cce5 100644
--- a/src/webapi/router/router_self.go
+++ b/center/router/router_self.go
@@ -1,14 +1,14 @@
package router
import (
+ "github.com/ccfos/nightingale/v6/models"
+ "github.com/ccfos/nightingale/v6/pkg/ormx"
+
"github.com/gin-gonic/gin"
"github.com/toolkits/pkg/ginx"
-
- "github.com/didi/nightingale/v5/src/models"
- "github.com/didi/nightingale/v5/src/pkg/ormx"
)
-func selfProfileGet(c *gin.Context) {
+func (rt *Router) selfProfileGet(c *gin.Context) {
user := c.MustGet("user").(*models.User)
if user.IsAdmin() {
user.Admin = true
@@ -24,7 +24,7 @@ type selfProfileForm struct {
Contacts ormx.JSONObj `json:"contacts"`
}
-func selfProfilePut(c *gin.Context) {
+func (rt *Router) selfProfilePut(c *gin.Context) {
var f selfProfileForm
ginx.BindJSON(c, &f)
@@ -36,7 +36,7 @@ func selfProfilePut(c *gin.Context) {
user.Contacts = f.Contacts
user.UpdateBy = user.Username
- ginx.NewRender(c).Message(user.UpdateAllFields())
+ ginx.NewRender(c).Message(user.UpdateAllFields(rt.Ctx))
}
type selfPasswordForm struct {
@@ -44,9 +44,9 @@ type selfPasswordForm struct {
NewPass string `json:"newpass" binding:"required"`
}
-func selfPasswordPut(c *gin.Context) {
+func (rt *Router) selfPasswordPut(c *gin.Context) {
var f selfPasswordForm
ginx.BindJSON(c, &f)
user := c.MustGet("user").(*models.User)
- ginx.NewRender(c).Message(user.ChangePassword(f.OldPass, f.NewPass))
+ ginx.NewRender(c).Message(user.ChangePassword(rt.Ctx, f.OldPass, f.NewPass))
}
diff --git a/center/router/router_server.go b/center/router/router_server.go
new file mode 100644
index 0000000000000000000000000000000000000000..21b27535ba9d22fe9a2da78188cff8d07cae0c9e
--- /dev/null
+++ b/center/router/router_server.go
@@ -0,0 +1,18 @@
+package router
+
+import (
+ "github.com/ccfos/nightingale/v6/models"
+
+ "github.com/gin-gonic/gin"
+ "github.com/toolkits/pkg/ginx"
+)
+
+func (rt *Router) serversGet(c *gin.Context) {
+ list, err := models.AlertingEngineGets(rt.Ctx, "")
+ ginx.NewRender(c).Data(list, err)
+}
+
+func (rt *Router) serverClustersGet(c *gin.Context) {
+ list, err := models.AlertingEngineGetsClusters(rt.Ctx, "")
+ ginx.NewRender(c).Data(list, err)
+}
diff --git a/src/webapi/router/router_target.go b/center/router/router_target.go
similarity index 61%
rename from src/webapi/router/router_target.go
rename to center/router/router_target.go
index cde7d130b657e6fb81cff9df196534e3fdcaf9cb..55c8d160f6147c9132f06d065a9ad194c4e689d7 100644
--- a/src/webapi/router/router_target.go
+++ b/center/router/router_target.go
@@ -4,56 +4,79 @@ import (
"context"
"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/prom"
+
"github.com/gin-gonic/gin"
"github.com/prometheus/common/model"
"github.com/toolkits/pkg/ginx"
-
- "github.com/didi/nightingale/v5/src/models"
- "github.com/didi/nightingale/v5/src/server/common/conv"
- "github.com/didi/nightingale/v5/src/webapi/config"
- "github.com/didi/nightingale/v5/src/webapi/prom"
)
-func targetGets(c *gin.Context) {
+type TargetQuery struct {
+ Filters []models.HostQuery `json:"queries"`
+ P int `json:"p"`
+ Limit int `json:"limit"`
+}
+
+func (rt *Router) targetGetsByHostFilter(c *gin.Context) {
+ var f TargetQuery
+ ginx.BindJSON(c, &f)
+
+ query := models.GetHostsQuery(f.Filters)
+
+ hosts, err := models.TargetGetsByFilter(rt.Ctx, query, "", 0, f.Limit, (f.P-1)*f.Limit)
+ ginx.Dangerous(err)
+
+ total, err := models.TargetCountByFilter(rt.Ctx, query, "", 0)
+ ginx.Dangerous(err)
+
+ ginx.NewRender(c).Data(gin.H{
+ "list": hosts,
+ "total": total,
+ }, nil)
+}
+
+func (rt *Router) targetGets(c *gin.Context) {
bgid := ginx.QueryInt64(c, "bgid", -1)
query := ginx.QueryStr(c, "query", "")
limit := ginx.QueryInt(c, "limit", 30)
mins := ginx.QueryInt(c, "mins", 2)
- clusters := queryClusters(c)
+ dsIds := queryDatasourceIds(c)
- total, err := models.TargetTotal(bgid, clusters, query)
+ total, err := models.TargetTotal(rt.Ctx, bgid, dsIds, query)
ginx.Dangerous(err)
- list, err := models.TargetGets(bgid, clusters, query, limit, ginx.Offset(c, limit))
+ list, err := models.TargetGets(rt.Ctx, bgid, dsIds, query, limit, ginx.Offset(c, limit))
ginx.Dangerous(err)
if err == nil {
+ now := time.Now()
cache := make(map[int64]*models.BusiGroup)
targetsMap := make(map[string]*models.Target)
for i := 0; i < len(list); i++ {
- ginx.Dangerous(list[i].FillGroup(cache))
- targetsMap[list[i].Cluster+list[i].Ident] = list[i]
+ ginx.Dangerous(list[i].FillGroup(rt.Ctx, cache))
+ targetsMap[strconv.FormatInt(list[i].DatasourceId, 10)+list[i].Ident] = list[i]
+ if now.Unix()-list[i].UpdateAt < 60 {
+ list[i].TargetUp = 1
+ }
}
- now := time.Now()
-
// query LoadPerCore / MemUtil / TargetUp / DiskUsedPercent from prometheus
// map key: cluster, map value: ident list
- targets := make(map[string][]string)
+ targets := make(map[int64][]string)
for i := 0; i < len(list); i++ {
- targets[list[i].Cluster] = append(targets[list[i].Cluster], list[i].Ident)
+ targets[list[i].DatasourceId] = append(targets[list[i].DatasourceId], list[i].Ident)
}
- for cluster := range targets {
- cc, has := prom.Clusters.Get(cluster)
- if !has {
- continue
- }
+ for dsId := range targets {
+ cc := rt.PromClients.GetCli(dsId)
- targetArr := targets[cluster]
+ targetArr := targets[dsId]
if len(targetArr) == 0 {
continue
}
@@ -61,7 +84,7 @@ func targetGets(c *gin.Context) {
targetRe := strings.Join(targetArr, "|")
valuesMap := make(map[string]map[string]float64)
- for metric, ql := range config.C.TargetMetrics {
+ for metric, ql := range rt.Center.TargetMetrics {
promql := fmt.Sprintf(ql, targetRe, mins)
values, err := instantQuery(context.Background(), cc, promql, now)
ginx.Dangerous(err)
@@ -71,15 +94,13 @@ func targetGets(c *gin.Context) {
// handle values
for metric, values := range valuesMap {
for ident := range values {
- mapkey := cluster + ident
+ mapkey := strconv.FormatInt(dsId, 10) + ident
if t, has := targetsMap[mapkey]; has {
switch metric {
case "LoadPerCore":
t.LoadPerCore = values[ident]
case "MemUtil":
t.MemUtil = values[ident]
- case "TargetUp":
- t.TargetUp = values[ident]
case "DiskUtil":
t.DiskUtil = values[ident]
}
@@ -95,10 +116,10 @@ func targetGets(c *gin.Context) {
}, nil)
}
-func instantQuery(ctx context.Context, c *prom.ClusterType, promql string, ts time.Time) (map[string]float64, error) {
+func instantQuery(ctx context.Context, c prom.API, promql string, ts time.Time) (map[string]float64, error) {
ret := make(map[string]float64)
- val, warnings, err := c.PromClient.Query(ctx, promql, ts)
+ val, warnings, err := c.Query(ctx, promql, ts)
if err != nil {
return ret, err
}
@@ -107,7 +128,8 @@ func instantQuery(ctx context.Context, c *prom.ClusterType, promql string, ts ti
return ret, fmt.Errorf("instant query occur warnings, promql: %s, warnings: %v", promql, warnings)
}
- vectors := conv.ConvertVectors(val)
+ // TODO 替换函数
+ vectors := common.ConvertAnomalyPoints(val)
for i := range vectors {
ident, has := vectors[i].Labels["ident"]
if has {
@@ -118,10 +140,10 @@ func instantQuery(ctx context.Context, c *prom.ClusterType, promql string, ts ti
return ret, nil
}
-func targetGetTags(c *gin.Context) {
- idents := ginx.QueryStr(c, "idents")
+func (rt *Router) targetGetTags(c *gin.Context) {
+ idents := ginx.QueryStr(c, "idents", "")
idents = strings.ReplaceAll(idents, ",", " ")
- lst, err := models.TargetGetTags(strings.Fields(idents))
+ lst, err := models.TargetGetTags(rt.Ctx, strings.Fields(idents))
ginx.NewRender(c).Data(lst, err)
}
@@ -134,7 +156,7 @@ func (t targetTagsForm) Verify() {
}
-func targetBindTagsByFE(c *gin.Context) {
+func (rt *Router) targetBindTagsByFE(c *gin.Context) {
var f targetTagsForm
ginx.BindJSON(c, &f)
@@ -142,12 +164,12 @@ func targetBindTagsByFE(c *gin.Context) {
ginx.Bomb(http.StatusBadRequest, "idents empty")
}
- checkTargetPerm(c, f.Idents)
+ rt.checkTargetPerm(c, f.Idents)
- ginx.NewRender(c).Message(targetBindTags(f))
+ ginx.NewRender(c).Message(rt.targetBindTags(f))
}
-func targetBindTagsByService(c *gin.Context) {
+func (rt *Router) targetBindTagsByService(c *gin.Context) {
var f targetTagsForm
ginx.BindJSON(c, &f)
@@ -155,10 +177,10 @@ func targetBindTagsByService(c *gin.Context) {
ginx.Bomb(http.StatusBadRequest, "idents empty")
}
- ginx.NewRender(c).Message(targetBindTags(f))
+ ginx.NewRender(c).Message(rt.targetBindTags(f))
}
-func targetBindTags(f targetTagsForm) error {
+func (rt *Router) targetBindTags(f targetTagsForm) error {
for i := 0; i < len(f.Tags); i++ {
arr := strings.Split(f.Tags[i], "=")
if len(arr) != 2 {
@@ -183,7 +205,7 @@ func targetBindTags(f targetTagsForm) error {
}
for i := 0; i < len(f.Idents); i++ {
- target, err := models.TargetGetByIdent(f.Idents[i])
+ target, err := models.TargetGetByIdent(rt.Ctx, f.Idents[i])
if err != nil {
return err
}
@@ -201,7 +223,7 @@ func targetBindTags(f targetTagsForm) error {
}
}
- err = target.AddTags(f.Tags)
+ err = target.AddTags(rt.Ctx, f.Tags)
if err != nil {
return err
}
@@ -209,7 +231,7 @@ func targetBindTags(f targetTagsForm) error {
return nil
}
-func targetUnbindTagsByFE(c *gin.Context) {
+func (rt *Router) targetUnbindTagsByFE(c *gin.Context) {
var f targetTagsForm
ginx.BindJSON(c, &f)
@@ -217,12 +239,12 @@ func targetUnbindTagsByFE(c *gin.Context) {
ginx.Bomb(http.StatusBadRequest, "idents empty")
}
- checkTargetPerm(c, f.Idents)
+ rt.checkTargetPerm(c, f.Idents)
- ginx.NewRender(c).Message(targetUnbindTags(f))
+ ginx.NewRender(c).Message(rt.targetUnbindTags(f))
}
-func targetUnbindTagsByService(c *gin.Context) {
+func (rt *Router) targetUnbindTagsByService(c *gin.Context) {
var f targetTagsForm
ginx.BindJSON(c, &f)
@@ -230,12 +252,12 @@ func targetUnbindTagsByService(c *gin.Context) {
ginx.Bomb(http.StatusBadRequest, "idents empty")
}
- ginx.NewRender(c).Message(targetUnbindTags(f))
+ ginx.NewRender(c).Message(rt.targetUnbindTags(f))
}
-func targetUnbindTags(f targetTagsForm) error {
+func (rt *Router) targetUnbindTags(f targetTagsForm) error {
for i := 0; i < len(f.Idents); i++ {
- target, err := models.TargetGetByIdent(f.Idents[i])
+ target, err := models.TargetGetByIdent(rt.Ctx, f.Idents[i])
if err != nil {
return err
}
@@ -244,7 +266,7 @@ func targetUnbindTags(f targetTagsForm) error {
continue
}
- err = target.DelTags(f.Tags)
+ err = target.DelTags(rt.Ctx, f.Tags)
if err != nil {
return err
}
@@ -257,7 +279,7 @@ type targetNoteForm struct {
Note string `json:"note"`
}
-func targetUpdateNote(c *gin.Context) {
+func (rt *Router) targetUpdateNote(c *gin.Context) {
var f targetNoteForm
ginx.BindJSON(c, &f)
@@ -265,12 +287,12 @@ func targetUpdateNote(c *gin.Context) {
ginx.Bomb(http.StatusBadRequest, "idents empty")
}
- checkTargetPerm(c, f.Idents)
+ rt.checkTargetPerm(c, f.Idents)
- ginx.NewRender(c).Message(models.TargetUpdateNote(f.Idents, f.Note))
+ ginx.NewRender(c).Message(models.TargetUpdateNote(rt.Ctx, f.Idents, f.Note))
}
-func targetUpdateNoteByService(c *gin.Context) {
+func (rt *Router) targetUpdateNoteByService(c *gin.Context) {
var f targetNoteForm
ginx.BindJSON(c, &f)
@@ -278,7 +300,7 @@ func targetUpdateNoteByService(c *gin.Context) {
ginx.Bomb(http.StatusBadRequest, "idents empty")
}
- ginx.NewRender(c).Message(models.TargetUpdateNote(f.Idents, f.Note))
+ ginx.NewRender(c).Message(models.TargetUpdateNote(rt.Ctx, f.Idents, f.Note))
}
type targetBgidForm struct {
@@ -286,7 +308,7 @@ type targetBgidForm struct {
Bgid int64 `json:"bgid"`
}
-func targetUpdateBgid(c *gin.Context) {
+func (rt *Router) targetUpdateBgid(c *gin.Context) {
var f targetBgidForm
ginx.BindJSON(c, &f)
@@ -296,7 +318,7 @@ func targetUpdateBgid(c *gin.Context) {
user := c.MustGet("user").(*models.User)
if user.IsAdmin() {
- ginx.NewRender(c).Message(models.TargetUpdateBgid(f.Idents, f.Bgid, false))
+ ginx.NewRender(c).Message(models.TargetUpdateBgid(rt.Ctx, f.Idents, f.Bgid, false))
return
}
@@ -304,7 +326,7 @@ func targetUpdateBgid(c *gin.Context) {
// 把要操作的机器分成两部分，一部分是bgid为0，需要管理员分配，另一部分bgid>0，说明是业务组内部想调整
// 比如原来分配给didiyun的机器，didiyun的管理员想把部分机器调整到didiyun-ceph下
// 对于调整的这种情况，当前登录用户要对这批机器有操作权限，同时还要对目标BG有操作权限
- orphans, err := models.IdentsFilter(f.Idents, "group_id = ?", 0)
+ orphans, err := models.IdentsFilter(rt.Ctx, f.Idents, "group_id = ?", 0)
ginx.Dangerous(err)
// 机器里边存在未归组的，登录用户就需要是admin
@@ -312,15 +334,15 @@ func targetUpdateBgid(c *gin.Context) {
ginx.Bomb(http.StatusForbidden, "No permission. Only admin can assign BG")
}
- reBelongs, err := models.IdentsFilter(f.Idents, "group_id > ?", 0)
+ reBelongs, err := models.IdentsFilter(rt.Ctx, f.Idents, "group_id > ?", 0)
ginx.Dangerous(err)
if len(reBelongs) > 0 {
// 对于这些要重新分配的机器，操作者要对这些机器本身有权限，同时要对目标bgid有权限
- checkTargetPerm(c, f.Idents)
+ rt.checkTargetPerm(c, f.Idents)
- bg := BusiGroup(f.Bgid)
- can, err := user.CanDoBusiGroup(bg, "rw")
+ bg := BusiGroup(rt.Ctx, f.Bgid)
+ can, err := user.CanDoBusiGroup(rt.Ctx, bg, "rw")
ginx.Dangerous(err)
if !can {
@@ -329,19 +351,19 @@ func targetUpdateBgid(c *gin.Context) {
}
} else if f.Bgid == 0 {
// 退还机器
- checkTargetPerm(c, f.Idents)
+ rt.checkTargetPerm(c, f.Idents)
} else {
ginx.Bomb(http.StatusBadRequest, "invalid bgid")
}
- ginx.NewRender(c).Message(models.TargetUpdateBgid(f.Idents, f.Bgid, false))
+ ginx.NewRender(c).Message(models.TargetUpdateBgid(rt.Ctx, f.Idents, f.Bgid, false))
}
type identsForm struct {
Idents []string `json:"idents" binding:"required"`
}
-func targetDel(c *gin.Context) {
+func (rt *Router) targetDel(c *gin.Context) {
var f identsForm
ginx.BindJSON(c, &f)
@@ -349,14 +371,14 @@ func targetDel(c *gin.Context) {
ginx.Bomb(http.StatusBadRequest, "idents empty")
}
- checkTargetPerm(c, f.Idents)
+ rt.checkTargetPerm(c, f.Idents)
- ginx.NewRender(c).Message(models.TargetDel(f.Idents))
+ ginx.NewRender(c).Message(models.TargetDel(rt.Ctx, f.Idents))
}
-func checkTargetPerm(c *gin.Context, idents []string) {
+func (rt *Router) checkTargetPerm(c *gin.Context, idents []string) {
user := c.MustGet("user").(*models.User)
- nopri, err := user.NopriIdents(idents)
+ nopri, err := user.NopriIdents(rt.Ctx, idents)
ginx.Dangerous(err)
if len(nopri) > 0 {
diff --git a/src/webapi/router/router_task.go b/center/router/router_task.go
similarity index 82%
rename from src/webapi/router/router_task.go
rename to center/router/router_task.go
index 545c95202ca5f360bb5aecf05269ed4bd14821b9..b1ce98b599e7861b572623de0fc1ee52832838f6 100644
--- a/src/webapi/router/router_task.go
+++ b/center/router/router_task.go
@@ -8,15 +8,14 @@ import (
"strings"
"time"
+ "github.com/ccfos/nightingale/v6/models"
+
"github.com/gin-gonic/gin"
"github.com/toolkits/pkg/ginx"
"github.com/toolkits/pkg/str"
-
- "github.com/didi/nightingale/v5/src/models"
- "github.com/didi/nightingale/v5/src/webapi/config"
)
-func taskGets(c *gin.Context) {
+func (rt *Router) taskGets(c *gin.Context) {
bgid := ginx.UrlParamInt64(c, "id")
mine := ginx.QueryBool(c, "mine", false)
days := ginx.QueryInt64(c, "days", 7)
@@ -31,10 +30,10 @@ func taskGets(c *gin.Context) {
beginTime := time.Now().Unix() - days*24*3600
- total, err := models.TaskRecordTotal(bgid, beginTime, creator, query)
+ total, err := models.TaskRecordTotal(rt.Ctx, bgid, beginTime, creator, query)
ginx.Dangerous(err)
- list, err := models.TaskRecordGets(bgid, beginTime, creator, query, limit, ginx.Offset(c, limit))
+ list, err := models.TaskRecordGets(rt.Ctx, bgid, beginTime, creator, query, limit, ginx.Offset(c, limit))
ginx.Dangerous(err)
ginx.NewRender(c).Data(gin.H{
@@ -121,7 +120,7 @@ func (f *taskForm) HandleFH(fh string) {
f.Title = f.Title + " FH: " + fh
}
-func taskAdd(c *gin.Context) {
+func (rt *Router) taskAdd(c *gin.Context) {
var f taskForm
ginx.BindJSON(c, &f)
@@ -135,10 +134,10 @@ func taskAdd(c *gin.Context) {
f.HandleFH(f.Hosts[0])
// check permission
- checkTargetPerm(c, f.Hosts)
+ rt.checkTargetPerm(c, f.Hosts)
// call ibex
- taskId, err := TaskCreate(f)
+ taskId, err := TaskCreate(f, rt.Center.Ibex)
ginx.Dangerous(err)
if taskId <= 0 {
@@ -149,9 +148,9 @@ func taskAdd(c *gin.Context) {
record := models.TaskRecord{
Id: taskId,
GroupId: bgid,
- IbexAddress: config.C.Ibex.Address,
- IbexAuthUser: config.C.Ibex.BasicAuthUser,
- IbexAuthPass: config.C.Ibex.BasicAuthPass,
+ IbexAddress: rt.Center.Ibex.Address,
+ IbexAuthUser: rt.Center.Ibex.BasicAuthUser,
+ IbexAuthPass: rt.Center.Ibex.BasicAuthPass,
Title: f.Title,
Account: f.Account,
Batch: f.Batch,
@@ -164,14 +163,14 @@ func taskAdd(c *gin.Context) {
CreateBy: f.Creator,
}
- err = record.Add()
+ err = record.Add(rt.Ctx)
ginx.NewRender(c).Data(taskId, err)
}
-func taskProxy(c *gin.Context) {
- target, err := url.Parse(config.C.Ibex.Address)
+func (rt *Router) taskProxy(c *gin.Context) {
+ target, err := url.Parse(rt.Center.Ibex.Address)
if err != nil {
- ginx.NewRender(c).Message("invalid ibex address: %s", config.C.Ibex.Address)
+ ginx.NewRender(c).Message("invalid ibex address: %s", rt.Center.Ibex.Address)
return
}
@@ -193,8 +192,8 @@ func taskProxy(c *gin.Context) {
req.URL.RawQuery = target.RawQuery + "&" + req.URL.RawQuery
}
- if config.C.Ibex.BasicAuthUser != "" {
- req.SetBasicAuth(config.C.Ibex.BasicAuthUser, config.C.Ibex.BasicAuthPass)
+ if rt.Center.Ibex.BasicAuthUser != "" {
+ req.SetBasicAuth(rt.Center.Ibex.BasicAuthUser, rt.Center.Ibex.BasicAuthPass)
}
}
diff --git a/src/webapi/router/router_task_tpl.go b/center/router/router_task_tpl.go
similarity index 75%
rename from src/webapi/router/router_task_tpl.go
rename to center/router/router_task_tpl.go
index 60b9e306ac9f26053e0ab82486bd1aa361bc0c76..a4a36ee0720afe1954fa46bfa632913f040fe279 100644
--- a/src/webapi/router/router_task_tpl.go
+++ b/center/router/router_task_tpl.go
@@ -6,22 +6,22 @@ import (
"strings"
"time"
+ "github.com/ccfos/nightingale/v6/models"
+
"github.com/gin-gonic/gin"
"github.com/toolkits/pkg/ginx"
"github.com/toolkits/pkg/str"
-
- "github.com/didi/nightingale/v5/src/models"
)
-func taskTplGets(c *gin.Context) {
+func (rt *Router) taskTplGets(c *gin.Context) {
query := ginx.QueryStr(c, "query", "")
limit := ginx.QueryInt(c, "limit", 20)
groupId := ginx.UrlParamInt64(c, "id")
- total, err := models.TaskTplTotal(groupId, query)
+ total, err := models.TaskTplTotal(rt.Ctx, groupId, query)
ginx.Dangerous(err)
- list, err := models.TaskTplGets(groupId, query, limit, ginx.Offset(c, limit))
+ list, err := models.TaskTplGets(rt.Ctx, groupId, query, limit, ginx.Offset(c, limit))
ginx.Dangerous(err)
ginx.NewRender(c).Data(gin.H{
@@ -30,17 +30,17 @@ func taskTplGets(c *gin.Context) {
}, nil)
}
-func taskTplGet(c *gin.Context) {
+func (rt *Router) taskTplGet(c *gin.Context) {
tid := ginx.UrlParamInt64(c, "tid")
- tpl, err := models.TaskTplGet("id = ?", tid)
+ tpl, err := models.TaskTplGet(rt.Ctx, "id = ?", tid)
ginx.Dangerous(err)
if tpl == nil {
ginx.Bomb(404, "no such task template")
}
- hosts, err := tpl.Hosts()
+ hosts, err := tpl.Hosts(rt.Ctx)
ginx.NewRender(c).Data(gin.H{
"tpl": tpl,
@@ -61,7 +61,7 @@ type taskTplForm struct {
Hosts []string `json:"hosts"`
}
-func taskTplAdd(c *gin.Context) {
+func (rt *Router) taskTplAdd(c *gin.Context) {
var f taskTplForm
ginx.BindJSON(c, &f)
@@ -87,13 +87,13 @@ func taskTplAdd(c *gin.Context) {
UpdateAt: now,
}
- ginx.NewRender(c).Message(tpl.Save(f.Hosts))
+ ginx.NewRender(c).Message(tpl.Save(rt.Ctx, f.Hosts))
}
-func taskTplPut(c *gin.Context) {
+func (rt *Router) taskTplPut(c *gin.Context) {
tid := ginx.UrlParamInt64(c, "tid")
- tpl, err := models.TaskTplGet("id = ?", tid)
+ tpl, err := models.TaskTplGet(rt.Ctx, "id = ?", tid)
ginx.Dangerous(err)
if tpl == nil {
@@ -120,13 +120,13 @@ func taskTplPut(c *gin.Context) {
tpl.UpdateBy = user.Username
tpl.UpdateAt = time.Now().Unix()
- ginx.NewRender(c).Message(tpl.Update(f.Hosts))
+ ginx.NewRender(c).Message(tpl.Update(rt.Ctx, f.Hosts))
}
-func taskTplDel(c *gin.Context) {
+func (rt *Router) taskTplDel(c *gin.Context) {
tid := ginx.UrlParamInt64(c, "tid")
- tpl, err := models.TaskTplGet("id = ?", tid)
+ tpl, err := models.TaskTplGet(rt.Ctx, "id = ?", tid)
ginx.Dangerous(err)
if tpl == nil {
@@ -134,7 +134,7 @@ func taskTplDel(c *gin.Context) {
return
}
- ginx.NewRender(c).Message(tpl.Del())
+ ginx.NewRender(c).Message(tpl.Del(rt.Ctx))
}
type tplTagsForm struct {
@@ -171,7 +171,7 @@ func (f *tplTagsForm) Verify() {
}
}
-func taskTplBindTags(c *gin.Context) {
+func (rt *Router) taskTplBindTags(c *gin.Context) {
var f tplTagsForm
ginx.BindJSON(c, &f)
f.Verify()
@@ -179,20 +179,20 @@ func taskTplBindTags(c *gin.Context) {
username := c.MustGet("username").(string)
for i := 0; i < len(f.Ids); i++ {
- tpl, err := models.TaskTplGet("id = ?", f.Ids[i])
+ tpl, err := models.TaskTplGet(rt.Ctx, "id = ?", f.Ids[i])
ginx.Dangerous(err)
if tpl == nil {
continue
}
- ginx.Dangerous(tpl.AddTags(f.Tags, username))
+ ginx.Dangerous(tpl.AddTags(rt.Ctx, f.Tags, username))
}
ginx.NewRender(c).Message(nil)
}
-func taskTplUnbindTags(c *gin.Context) {
+func (rt *Router) taskTplUnbindTags(c *gin.Context) {
var f tplTagsForm
ginx.BindJSON(c, &f)
f.Verify()
@@ -200,14 +200,14 @@ func taskTplUnbindTags(c *gin.Context) {
username := c.MustGet("username").(string)
for i := 0; i < len(f.Ids); i++ {
- tpl, err := models.TaskTplGet("id = ?", f.Ids[i])
+ tpl, err := models.TaskTplGet(rt.Ctx, "id = ?", f.Ids[i])
ginx.Dangerous(err)
if tpl == nil {
continue
}
- ginx.Dangerous(tpl.DelTags(f.Tags, username))
+ ginx.Dangerous(tpl.DelTags(rt.Ctx, f.Tags, username))
}
ginx.NewRender(c).Message(nil)
diff --git a/src/webapi/router/router_user.go b/center/router/router_user.go
similarity index 65%
rename from src/webapi/router/router_user.go
rename to center/router/router_user.go
index 5b25d80513c1ab9d3aa27cc9c44f978f662e5217..3f4646a3f6ab61b13c93c2435d54986fa161f1a4 100644
--- a/src/webapi/router/router_user.go
+++ b/center/router/router_user.go
@@ -4,21 +4,21 @@ import (
"net/http"
"strings"
+ "github.com/ccfos/nightingale/v6/models"
+ "github.com/ccfos/nightingale/v6/pkg/ormx"
+
"github.com/gin-gonic/gin"
"github.com/toolkits/pkg/ginx"
-
- "github.com/didi/nightingale/v5/src/models"
- "github.com/didi/nightingale/v5/src/pkg/ormx"
)
-func userFindAll(c *gin.Context) {
+func (rt *Router) userFindAll(c *gin.Context) {
limit := ginx.QueryInt(c, "limit", 20)
query := ginx.QueryStr(c, "query", "")
- total, err := models.UserTotal(query)
+ total, err := models.UserTotal(rt.Ctx, query)
ginx.Dangerous(err)
- list, err := models.UserGets(query, limit, ginx.Offset(c, limit))
+ list, err := models.UserGets(rt.Ctx, query, limit, ginx.Offset(c, limit))
ginx.Dangerous(err)
ginx.NewRender(c).Data(gin.H{
@@ -27,14 +27,14 @@ func userFindAll(c *gin.Context) {
}, nil)
}
-func userGets(c *gin.Context) {
+func (rt *Router) userGets(c *gin.Context) {
limit := ginx.QueryInt(c, "limit", 20)
query := ginx.QueryStr(c, "query", "")
- total, err := models.UserTotal(query)
+ total, err := models.UserTotal(rt.Ctx, query)
ginx.Dangerous(err)
- list, err := models.UserGets(query, limit, ginx.Offset(c, limit))
+ list, err := models.UserGets(rt.Ctx, query, limit, ginx.Offset(c, limit))
ginx.Dangerous(err)
user := c.MustGet("user").(*models.User)
@@ -57,11 +57,11 @@ type userAddForm struct {
Contacts ormx.JSONObj `json:"contacts"`
}
-func userAddPost(c *gin.Context) {
+func (rt *Router) userAddPost(c *gin.Context) {
var f userAddForm
ginx.BindJSON(c, &f)
- password, err := models.CryptoPass(f.Password)
+ password, err := models.CryptoPass(rt.Ctx, f.Password)
ginx.Dangerous(err)
if len(f.Roles) == 0 {
@@ -83,11 +83,11 @@ func userAddPost(c *gin.Context) {
UpdateBy: user.Username,
}
- ginx.NewRender(c).Message(u.Add())
+ ginx.NewRender(c).Message(u.Add(rt.Ctx))
}
-func userProfileGet(c *gin.Context) {
- user := User(ginx.UrlParamInt64(c, "id"))
+func (rt *Router) userProfileGet(c *gin.Context) {
+ user := User(rt.Ctx, ginx.UrlParamInt64(c, "id"))
ginx.NewRender(c).Data(user, nil)
}
@@ -99,7 +99,7 @@ type userProfileForm struct {
Contacts ormx.JSONObj `json:"contacts"`
}
-func userProfilePut(c *gin.Context) {
+func (rt *Router) userProfilePut(c *gin.Context) {
var f userProfileForm
ginx.BindJSON(c, &f)
@@ -107,7 +107,7 @@ func userProfilePut(c *gin.Context) {
ginx.Bomb(http.StatusBadRequest, "roles empty")
}
- target := User(ginx.UrlParamInt64(c, "id"))
+ target := User(rt.Ctx, ginx.UrlParamInt64(c, "id"))
target.Nickname = f.Nickname
target.Phone = f.Phone
target.Email = f.Email
@@ -115,28 +115,28 @@ func userProfilePut(c *gin.Context) {
target.Contacts = f.Contacts
target.UpdateBy = c.MustGet("username").(string)
- ginx.NewRender(c).Message(target.UpdateAllFields())
+ ginx.NewRender(c).Message(target.UpdateAllFields(rt.Ctx))
}
type userPasswordForm struct {
Password string `json:"password" binding:"required"`
}
-func userPasswordPut(c *gin.Context) {
+func (rt *Router) userPasswordPut(c *gin.Context) {
var f userPasswordForm
ginx.BindJSON(c, &f)
- target := User(ginx.UrlParamInt64(c, "id"))
+ target := User(rt.Ctx, ginx.UrlParamInt64(c, "id"))
- cryptoPass, err := models.CryptoPass(f.Password)
+ cryptoPass, err := models.CryptoPass(rt.Ctx, f.Password)
ginx.Dangerous(err)
- ginx.NewRender(c).Message(target.UpdatePassword(cryptoPass, c.MustGet("username").(string)))
+ ginx.NewRender(c).Message(target.UpdatePassword(rt.Ctx, cryptoPass, c.MustGet("username").(string)))
}
-func userDel(c *gin.Context) {
+func (rt *Router) userDel(c *gin.Context) {
id := ginx.UrlParamInt64(c, "id")
- target, err := models.UserGetById(id)
+ target, err := models.UserGetById(rt.Ctx, id)
ginx.Dangerous(err)
if target == nil {
@@ -144,5 +144,5 @@ func userDel(c *gin.Context) {
return
}
- ginx.NewRender(c).Message(target.Del())
+ ginx.NewRender(c).Message(target.Del(rt.Ctx))
}
diff --git a/src/webapi/router/router_user_group.go b/center/router/router_user_group.go
similarity index 59%
rename from src/webapi/router/router_user_group.go
rename to center/router/router_user_group.go
index c5b653e4bde3ec612264014d080cb0e255f3006c..5d41e7a671d4b8070c7de317ea0ee8f3e26964a3 100644
--- a/src/webapi/router/router_user_group.go
+++ b/center/router/router_user_group.go
@@ -4,26 +4,27 @@ import (
"net/http"
"time"
+ "github.com/ccfos/nightingale/v6/models"
+
"github.com/gin-gonic/gin"
"github.com/toolkits/pkg/ginx"
-
- "github.com/didi/nightingale/v5/src/models"
+ "github.com/toolkits/pkg/logger"
)
-func checkBusiGroupPerm(c *gin.Context) {
+func (rt *Router) checkBusiGroupPerm(c *gin.Context) {
me := c.MustGet("user").(*models.User)
- bg := BusiGroup(ginx.UrlParamInt64(c, "id"))
+ bg := BusiGroup(rt.Ctx, ginx.UrlParamInt64(c, "id"))
- can, err := me.CanDoBusiGroup(bg, ginx.UrlParamStr(c, "perm"))
+ can, err := me.CanDoBusiGroup(rt.Ctx, bg, ginx.UrlParamStr(c, "perm"))
ginx.NewRender(c).Data(can, err)
}
-func userGroupGets(c *gin.Context) {
+func (rt *Router) userGroupGets(c *gin.Context) {
limit := ginx.QueryInt(c, "limit", 1500)
query := ginx.QueryStr(c, "query", "")
me := c.MustGet("user").(*models.User)
- lst, err := me.UserGroups(limit, query)
+ lst, err := me.UserGroups(rt.Ctx, limit, query)
ginx.NewRender(c).Data(lst, err)
}
@@ -33,7 +34,7 @@ type userGroupForm struct {
Note string `json:"note"`
}
-func userGroupAdd(c *gin.Context) {
+func (rt *Router) userGroupAdd(c *gin.Context) {
var f userGroupForm
ginx.BindJSON(c, &f)
@@ -46,16 +47,16 @@ func userGroupAdd(c *gin.Context) {
UpdateBy: me.Username,
}
- err := ug.Add()
+ err := ug.Add(rt.Ctx)
if err == nil {
// Even failure is not a big deal
- models.UserGroupMemberAdd(ug.Id, me.Id)
+ models.UserGroupMemberAdd(rt.Ctx, ug.Id, me.Id)
}
ginx.NewRender(c).Data(ug.Id, err)
}
-func userGroupPut(c *gin.Context) {
+func (rt *Router) userGroupPut(c *gin.Context) {
var f userGroupForm
ginx.BindJSON(c, &f)
@@ -64,7 +65,7 @@ func userGroupPut(c *gin.Context) {
if ug.Name != f.Name {
// name changed, check duplication
- num, err := models.UserGroupCount("name=? and id<>?", f.Name, ug.Id)
+ num, err := models.UserGroupCount(rt.Ctx, "name=? and id<>?", f.Name, ug.Id)
ginx.Dangerous(err)
if num > 0 {
@@ -77,17 +78,18 @@ func userGroupPut(c *gin.Context) {
ug.UpdateBy = me.Username
ug.UpdateAt = time.Now().Unix()
- ginx.NewRender(c).Message(ug.Update("Name", "Note", "UpdateAt", "UpdateBy"))
+ ginx.NewRender(c).Message(ug.Update(rt.Ctx, "Name", "Note", "UpdateAt", "UpdateBy"))
}
// Return all members, front-end search and paging
-func userGroupGet(c *gin.Context) {
- ug := UserGroup(ginx.UrlParamInt64(c, "id"))
+func (rt *Router) userGroupGet(c *gin.Context) {
+ ug := UserGroup(rt.Ctx, ginx.UrlParamInt64(c, "id"))
- ids, err := models.MemberIds(ug.Id)
+ ids, err := models.MemberIds(rt.Ctx, ug.Id)
ginx.Dangerous(err)
- users, err := models.UserGetsByIds(ids)
+ logger.Info("userGroupGet", ids)
+ users, err := models.UserGetsByIds(rt.Ctx, ids)
ginx.NewRender(c).Data(gin.H{
"users": users,
@@ -95,12 +97,12 @@ func userGroupGet(c *gin.Context) {
}, err)
}
-func userGroupDel(c *gin.Context) {
+func (rt *Router) userGroupDel(c *gin.Context) {
ug := c.MustGet("user_group").(*models.UserGroup)
- ginx.NewRender(c).Message(ug.Del())
+ ginx.NewRender(c).Message(ug.Del(rt.Ctx))
}
-func userGroupMemberAdd(c *gin.Context) {
+func (rt *Router) userGroupMemberAdd(c *gin.Context) {
var f idsForm
ginx.BindJSON(c, &f)
f.Verify()
@@ -108,17 +110,17 @@ func userGroupMemberAdd(c *gin.Context) {
me := c.MustGet("user").(*models.User)
ug := c.MustGet("user_group").(*models.UserGroup)
- err := ug.AddMembers(f.Ids)
+ err := ug.AddMembers(rt.Ctx, f.Ids)
if err == nil {
ug.UpdateAt = time.Now().Unix()
ug.UpdateBy = me.Username
- ug.Update("UpdateAt", "UpdateBy")
+ ug.Update(rt.Ctx, "UpdateAt", "UpdateBy")
}
ginx.NewRender(c).Message(err)
}
-func userGroupMemberDel(c *gin.Context) {
+func (rt *Router) userGroupMemberDel(c *gin.Context) {
var f idsForm
ginx.BindJSON(c, &f)
f.Verify()
@@ -126,11 +128,11 @@ func userGroupMemberDel(c *gin.Context) {
me := c.MustGet("user").(*models.User)
ug := c.MustGet("user_group").(*models.UserGroup)
- err := ug.DelMembers(f.Ids)
+ err := ug.DelMembers(rt.Ctx, f.Ids)
if err == nil {
ug.UpdateAt = time.Now().Unix()
ug.UpdateBy = me.Username
- ug.Update("UpdateAt", "UpdateBy")
+ ug.Update(rt.Ctx, "UpdateAt", "UpdateBy")
}
ginx.NewRender(c).Message(err)
diff --git a/center/sso/init.go b/center/sso/init.go
new file mode 100644
index 0000000000000000000000000000000000000000..dcee321aa906c8519fc853336987322bb2fbe357
--- /dev/null
+++ b/center/sso/init.go
@@ -0,0 +1,76 @@
+package sso
+
+import (
+ "github.com/ccfos/nightingale/v6/center/cconf"
+ "github.com/ccfos/nightingale/v6/models"
+ "github.com/ccfos/nightingale/v6/pkg/cas"
+ "github.com/ccfos/nightingale/v6/pkg/ctx"
+ "github.com/ccfos/nightingale/v6/pkg/ldapx"
+ "github.com/ccfos/nightingale/v6/pkg/oauth2x"
+ "github.com/ccfos/nightingale/v6/pkg/oidcx"
+
+ "github.com/pelletier/go-toml/v2"
+ "github.com/toolkits/pkg/logger"
+)
+
+type SsoClient struct {
+ OIDC *oidcx.SsoClient
+ LDAP *ldapx.SsoClient
+ CAS *cas.SsoClient
+ OAuth2 *oauth2x.SsoClient
+}
+
+func Init(center cconf.Center, ctx *ctx.Context) *SsoClient {
+ ssoClient := new(SsoClient)
+ m := make(map[string]interface{})
+ m["LDAP"] = center.LDAP
+ m["CAS"] = center.CAS
+ m["OIDC"] = center.OIDC
+ m["OAuth2"] = center.OAuth
+
+ for name, config := range m {
+ b, err := toml.Marshal(config)
+ if err != nil {
+ logger.Error(err)
+ continue
+ }
+
+ count, err := models.SsoConfigCountByName(ctx, name)
+ if err != nil {
+ logger.Error(err)
+ continue
+ }
+
+ if count > 0 {
+ continue
+ }
+
+ ssoConfig := models.SsoConfig{
+ Name: name,
+ Content: string(b),
+ }
+
+ err = ssoConfig.Create(ctx)
+ if err != nil {
+ logger.Error(err)
+ }
+ }
+
+ // init ldap
+ ssoClient.LDAP = ldapx.New(center.LDAP)
+
+ // init oidc
+ oidcClient, err := oidcx.New(center.OIDC)
+ if err != nil {
+ logger.Error("init oidc failed: %v", err)
+ } else {
+ ssoClient.OIDC = oidcClient
+ }
+
+ // init cas
+ ssoClient.CAS = cas.New(center.CAS)
+
+ // init oauth
+ ssoClient.OAuth2 = oauth2x.New(center.OAuth)
+ return ssoClient
+}
diff --git a/cli/cli.go b/cli/cli.go
new file mode 100644
index 0000000000000000000000000000000000000000..5ea14f176ed7e50a523dea266aa91a4b32bb2fe2
--- /dev/null
+++ b/cli/cli.go
@@ -0,0 +1,9 @@
+package cli
+
+import (
+ "github.com/ccfos/nightingale/v6/cli/upgrade"
+)
+
+func Upgrade(configFile string, sqlFile string) error {
+ return upgrade.Upgrade(configFile, sqlFile)
+}
diff --git a/cli/upgrade/config.go b/cli/upgrade/config.go
new file mode 100644
index 0000000000000000000000000000000000000000..235bc055f05766babbbde0c14cff5652318f4df8
--- /dev/null
+++ b/cli/upgrade/config.go
@@ -0,0 +1,63 @@
+package upgrade
+
+import (
+ "bytes"
+ "path"
+
+ "github.com/ccfos/nightingale/v6/pkg/cfg"
+ "github.com/ccfos/nightingale/v6/pkg/ormx"
+ "github.com/ccfos/nightingale/v6/pkg/tlsx"
+ "github.com/koding/multiconfig"
+)
+
+type Config struct {
+ DB ormx.DBConfig
+ Clusters []ClusterOptions
+}
+
+type ClusterOptions struct {
+ Name string
+ Prom string
+
+ BasicAuthUser string
+ BasicAuthPass string
+
+ Headers []string
+
+ Timeout int64
+ DialTimeout int64
+
+ UseTLS bool
+ tlsx.ClientConfig
+
+ MaxIdleConnsPerHost int
+}
+
+func Parse(fpath string, configPtr interface{}) error {
+ var (
+ tBuf []byte
+ )
+ loaders := []multiconfig.Loader{
+ &multiconfig.TagLoader{},
+ &multiconfig.EnvironmentLoader{},
+ }
+ s := cfg.NewFileScanner()
+
+ s.Read(path.Join(fpath))
+ tBuf = append(tBuf, s.Data()...)
+ tBuf = append(tBuf, []byte("\n")...)
+
+ if s.Err() != nil {
+ return s.Err()
+ }
+
+ if len(tBuf) != 0 {
+ loaders = append(loaders, &multiconfig.TOMLLoader{Reader: bytes.NewReader(tBuf)})
+ }
+
+ m := multiconfig.DefaultLoader{
+ Loader: multiconfig.MultiLoader(loaders...),
+ Validator: multiconfig.MultiValidator(&multiconfig.RequiredValidator{}),
+ }
+ return m.Load(configPtr)
+}
diff --git a/cli/upgrade/readme.md b/cli/upgrade/readme.md
new file mode 100644
index 0000000000000000000000000000000000000000..20e827dbb702745cabcd0e68d1535d0d6fe506a4
--- /dev/null
+++ b/cli/upgrade/readme.md
@@ -0,0 +1,5 @@
+1. 更新表结构
+2. 读取 webapi.conf 配置
+3. 集群配置写入数据库
+4. 将相关表中的 cluster 转换为 datasoruce_id
+5. 将告警规则中存储 runbook 的，存到 annotation 中
\ No newline at end of file
diff --git a/cli/upgrade/upgrade.go b/cli/upgrade/upgrade.go
new file mode 100644
index 0000000000000000000000000000000000000000..588a5cb3281d768379f438b3c67e1c8151c51c23
--- /dev/null
+++ b/cli/upgrade/upgrade.go
@@ -0,0 +1,84 @@
+package upgrade
+
+import (
+ "context"
+ "fmt"
+ "os/exec"
+
+ "github.com/ccfos/nightingale/v6/models"
+ "github.com/ccfos/nightingale/v6/pkg/ctx"
+ "github.com/ccfos/nightingale/v6/storage"
+
+ "github.com/go-sql-driver/mysql"
+)
+
+func Upgrade(configFile string, sqlFile string) error {
+ var config Config
+ Parse(configFile, &config)
+ dsnConf, _ := mysql.ParseDSN(config.DB.DSN)
+ passwd := dsnConf.Passwd
+ user := dsnConf.User
+
+ cmd := exec.Command("mysql", fmt.Sprintf("-u%s", user), fmt.Sprintf("-p%s", passwd), "<", sqlFile)
+ if err := cmd.Run(); err != nil {
+ return err
+ }
+
+ db, err := storage.New(config.DB)
+ if err != nil {
+ return err
+ }
+ ctx := ctx.NewContext(context.Background(), db)
+
+ datasources, err := models.GetDatasources(ctx)
+ if err != nil {
+ return err
+ }
+
+ m := make(map[string]models.Datasource)
+ for i := 0; i < len(datasources); i++ {
+ m[datasources[i].Name] = datasources[i]
+ }
+
+ err = models.AlertRuleUpgradeToV6(ctx, m)
+ if err != nil {
+ return err
+ }
+
+ // alert mute
+ err = models.AlertMuteUpgradeToV6(ctx, m)
+ if err != nil {
+ return err
+ }
+ // alert subscribe
+ err = models.AlertSubscribeUpgradeToV6(ctx, m)
+ if err != nil {
+ return err
+ }
+
+ // alert cur event
+ err = models.AlertCurEventUpgradeToV6(ctx, m)
+ if err != nil {
+ return err
+ }
+
+ // alert his event
+ err = models.AlertHisEventUpgradeToV6(ctx, m)
+ if err != nil {
+ return err
+ }
+
+ // target
+ err = models.TargetUpgradeToV6(ctx, m)
+ if err != nil {
+ return err
+ }
+
+ // recoding rule
+ err = models.RecordingRuleUpgradeToV6(ctx, m)
+ if err != nil {
+ return err
+ }
+
+ return nil
+}
diff --git a/cli/upgrade/upgrade.sql b/cli/upgrade/upgrade.sql
new file mode 100644
index 0000000000000000000000000000000000000000..2a3c577c2bd5b6cf072535dd5f1c6293439b255e
--- /dev/null
+++ b/cli/upgrade/upgrade.sql
@@ -0,0 +1,94 @@
+use n9e_v5;
+
+insert into `role_operation`(role_name, operation) values('Guest', '/log/explorer');
+insert into `role_operation`(role_name, operation) values('Guest', '/trace/explorer');
+
+insert into `role_operation`(role_name, operation) values('Standard', '/log/explorer');
+insert into `role_operation`(role_name, operation) values('Standard', '/trace/explorer');
+insert into `role_operation`(role_name, operation) values('Standard', '/alert-rules-built-in');
+insert into `role_operation`(role_name, operation) values('Standard', '/dashboards-built-in');
+insert into `role_operation`(role_name, operation) values('Standard', '/trace/dependencies');
+
+alter table `board` add built_in tinyint(1) not null default 0 comment '0:false 1:true';
+alter table `board` add hide tinyint(1) not null default 0 comment '0:false 1:true';
+
+alter table `chart_share` add datasource_id bigint unsigned not null default 0;
+
+alter table `alert_rule` add datasource_ids varchar(255) not null default '';
+alter table `alert_rule` add rule_config text not null comment 'rule_config';
+alter table `alert_rule` add annotations text not null comment 'annotations';
+
+alter table `alert_mute` add datasource_ids varchar(255) not null default '';
+alter table `alert_mute` add periodic_mutes varchar(4096) not null default '';
+alter table `alert_mute` add mute_time_type tinyint(1) not null default 0;
+
+alter table `alert_subscribe` add datasource_ids varchar(255) not null default '';
+alter table `alert_subscribe` add prod varchar(255) not null default '';
+alter table `alert_subscribe` add webhooks text;
+alter table `alert_subscribe` add redefine_webhooks tinyint(1) default 0;
+alter table `alert_subscribe` add for_duration bigint not null default 0;
+
+alter table `target` add datasource_id bigint unsigned not null default 0;
+alter table `target` add offset bigint not null default 0;
+alter table `target` modify cluster varchar(128) not null default '';
+
+alter table `recording_rule` add datasource_ids varchar(255) default '';
+
+alter table `alert_cur_event` add datasource_id bigint unsigned not null default 0;
+alter table `alert_cur_event` add annotations text not null comment 'annotations';
+alter table `alert_cur_event` add rule_config text not null comment 'rule_config';
+
+alter table `alert_his_event` add datasource_id bigint unsigned not null default 0;
+alter table `alert_his_event` add annotations text not null comment 'annotations';
+alter table `alert_his_event` add rule_config text not null comment 'rule_config';
+
+alter table alerting_engines add datasource_id bigint unsigned not null default 0;
+
+CREATE TABLE `datasource`
+(
+ `id` int unsigned NOT NULL AUTO_INCREMENT,
+ `name` varchar(255) not null default '',
+ `description` varchar(255) not null default '',
+ `category` varchar(255) not null default '',
+ `plugin_id` int unsigned not null default 0,
+ `plugin_type` varchar(255) not null default '',
+ `plugin_type_name` varchar(255) not null default '',
+ `cluster_name` varchar(255) not null default '',
+ `settings` text not null,
+ `status` varchar(255) not null default '',
+ `http` varchar(4096) not null default '',
+ `auth` varchar(8192) not null default '',
+ `created_at` bigint not null default 0,
+ `created_by` varchar(64) not null default '',
+ `updated_at` bigint not null default 0,
+ `updated_by` varchar(64) not null default '',
+ PRIMARY KEY (`id`)
+) ENGINE = InnoDB DEFAULT CHARSET = utf8mb4;
+
+CREATE TABLE `builtin_cate` (
+ `id` bigint unsigned not null auto_increment,
+ `name` varchar(191) not null,
+ `user_id` bigint not null default 0,
+ PRIMARY KEY (`id`)
+) ENGINE = InnoDB DEFAULT CHARSET = utf8mb4;
+
+CREATE TABLE `notify_tpl` (
+ `id` bigint unsigned not null auto_increment,
+ `channel` varchar(32) not null,
+ `name` varchar(255) not null,
+ `contact_key` varchar(255) not null,
+ `contact_key_name` varchar(255) not null,
+ `hide_contact` int not null default 0,
+ `hide_channel` int not null default 0,
+ `content` text not null,
+ PRIMARY KEY (`id`),
+ UNIQUE KEY (`channel`)
+) ENGINE = InnoDB DEFAULT CHARSET = utf8mb4;
+
+CREATE TABLE `sso_config` (
+ `id` bigint unsigned not null auto_increment,
+ `name` varchar(255) not null,
+ `content` text not null,
+ PRIMARY KEY (`id`),
+ UNIQUE KEY (`name`)
+) ENGINE = InnoDB DEFAULT CHARSET = utf8mb4;
\ No newline at end of file
diff --git a/cmd/alert/main.go b/cmd/alert/main.go
new file mode 100644
index 0000000000000000000000000000000000000000..e43b005b5dc0592f6d51aaad9fb49c9f7745ca25
--- /dev/null
+++ b/cmd/alert/main.go
@@ -0,0 +1,68 @@
+package main
+
+import (
+ "flag"
+ "fmt"
+ "log"
+ "os"
+ "os/signal"
+ "syscall"
+
+ "github.com/ccfos/nightingale/v6/alert"
+ "github.com/ccfos/nightingale/v6/pkg/osx"
+ "github.com/ccfos/nightingale/v6/pkg/version"
+ "github.com/toolkits/pkg/runner"
+)
+
+var (
+ showVersion = flag.Bool("version", false, "Show version.")
+ configDir = flag.String("configs", osx.GetEnv("N9E_CONFIGS", "etc"), "Specify configuration directory.(env:N9E_CONFIGS)")
+ cryptoKey = flag.String("crypto-key", "", "Specify the secret key for configuration file field encryption.")
+)
+
+func main() {
+ flag.Parse()
+
+ if *showVersion {
+ fmt.Println(version.Version)
+ os.Exit(0)
+ }
+
+ printEnv()
+
+ cleanFunc, err := alert.Initialize(*configDir, *cryptoKey)
+ if err != nil {
+ log.Fatalln("failed to initialize:", err)
+ }
+
+ code := 1
+ sc := make(chan os.Signal, 1)
+ signal.Notify(sc, syscall.SIGHUP, syscall.SIGINT, syscall.SIGTERM, syscall.SIGQUIT)
+
+EXIT:
+ for {
+ sig := <-sc
+ fmt.Println("received signal:", sig.String())
+ switch sig {
+ case syscall.SIGQUIT, syscall.SIGTERM, syscall.SIGINT:
+ code = 0
+ break EXIT
+ case syscall.SIGHUP:
+ // reload configuration?
+ default:
+ break EXIT
+ }
+ }
+
+ cleanFunc()
+ fmt.Println("process exited")
+ os.Exit(code)
+}
+
+func printEnv() {
+ runner.Init()
+ fmt.Println("runner.cwd:", runner.Cwd)
+ fmt.Println("runner.hostname:", runner.Hostname)
+ fmt.Println("runner.fd_limits:", runner.FdLimits())
+ fmt.Println("runner.vm_limits:", runner.VMLimits())
+}
diff --git a/cmd/center/main.go b/cmd/center/main.go
new file mode 100644
index 0000000000000000000000000000000000000000..48fb7632d6bb0553df524ed5256f4bd2ec6b0b9f
--- /dev/null
+++ b/cmd/center/main.go
@@ -0,0 +1,68 @@
+package main
+
+import (
+ "flag"
+ "fmt"
+ "log"
+ "os"
+ "os/signal"
+ "syscall"
+
+ "github.com/ccfos/nightingale/v6/center"
+ "github.com/ccfos/nightingale/v6/pkg/osx"
+ "github.com/ccfos/nightingale/v6/pkg/version"
+ "github.com/toolkits/pkg/runner"
+)
+
+var (
+ showVersion = flag.Bool("version", false, "Show version.")
+ configDir = flag.String("configs", osx.GetEnv("N9E_CONFIGS", "etc"), "Specify configuration directory.(env:N9E_CONFIGS)")
+ cryptoKey = flag.String("crypto-key", "", "Specify the secret key for configuration file field encryption.")
+)
+
+func main() {
+ flag.Parse()
+
+ if *showVersion {
+ fmt.Println(version.Version)
+ os.Exit(0)
+ }
+
+ printEnv()
+
+ cleanFunc, err := center.Initialize(*configDir, *cryptoKey)
+ if err != nil {
+ log.Fatalln("failed to initialize:", err)
+ }
+
+ code := 1
+ sc := make(chan os.Signal, 1)
+ signal.Notify(sc, syscall.SIGHUP, syscall.SIGINT, syscall.SIGTERM, syscall.SIGQUIT)
+
+EXIT:
+ for {
+ sig := <-sc
+ fmt.Println("received signal:", sig.String())
+ switch sig {
+ case syscall.SIGQUIT, syscall.SIGTERM, syscall.SIGINT:
+ code = 0
+ break EXIT
+ case syscall.SIGHUP:
+ // reload configuration?
+ default:
+ break EXIT
+ }
+ }
+
+ cleanFunc()
+ fmt.Println("process exited")
+ os.Exit(code)
+}
+
+func printEnv() {
+ runner.Init()
+ fmt.Println("runner.cwd:", runner.Cwd)
+ fmt.Println("runner.hostname:", runner.Hostname)
+ fmt.Println("runner.fd_limits:", runner.FdLimits())
+ fmt.Println("runner.vm_limits:", runner.VMLimits())
+}
diff --git a/cmd/cli/main.go b/cmd/cli/main.go
new file mode 100644
index 0000000000000000000000000000000000000000..c630319ee3db36e0e0badcdc2a0e785aa7a0d1f2
--- /dev/null
+++ b/cmd/cli/main.go
@@ -0,0 +1,46 @@
+package main
+
+import (
+ "flag"
+ "fmt"
+ "os"
+
+ "github.com/ccfos/nightingale/v6/cli"
+ "github.com/ccfos/nightingale/v6/pkg/version"
+)
+
+var (
+ upgrade = flag.Bool("upgrade", false, "Upgrade the database.")
+ showVersion = flag.Bool("version", false, "Show version.")
+ sqlFile = flag.String("sql", "", "Specify the sql file to be executed.")
+ configDir = flag.String("config", "", "Specify configuration directory.(env:N9E_CONFIGS)")
+)
+
+func main() {
+ flag.Parse()
+
+ if *showVersion {
+ fmt.Println(version.Version)
+ os.Exit(0)
+ }
+
+ if *upgrade {
+ if *sqlFile == "" {
+ fmt.Println("Please specify the sql file to be executed.")
+ os.Exit(1)
+ }
+
+ if *configDir == "" {
+ fmt.Println("Please specify the configuration directory.")
+ os.Exit(1)
+ }
+
+ err := cli.Upgrade(*configDir, *sqlFile)
+ if err != nil {
+ fmt.Println(err)
+ os.Exit(1)
+ }
+ fmt.Print("Upgrade successfully.")
+ os.Exit(0)
+ }
+}
diff --git a/cmd/pushgw/main.go b/cmd/pushgw/main.go
new file mode 100644
index 0000000000000000000000000000000000000000..55905b1c39d3fd47b9364bfc133df9e379e78492
--- /dev/null
+++ b/cmd/pushgw/main.go
@@ -0,0 +1,69 @@
+package main
+
+import (
+ "flag"
+ "fmt"
+ "log"
+ "os"
+ "os/signal"
+ "syscall"
+
+ "github.com/ccfos/nightingale/v6/pkg/osx"
+ "github.com/ccfos/nightingale/v6/pkg/version"
+ "github.com/ccfos/nightingale/v6/pushgw"
+
+ "github.com/toolkits/pkg/runner"
+)
+
+var (
+ showVersion = flag.Bool("version", false, "Show version.")
+ configDir = flag.String("configs", osx.GetEnv("N9E_CONFIGS", "etc"), "Specify configuration directory.(env:N9E_CONFIGS)")
+ cryptoKey = flag.String("crypto-key", "", "Specify the secret key for configuration file field encryption.")
+)
+
+func main() {
+ flag.Parse()
+
+ if *showVersion {
+ fmt.Println(version.Version)
+ os.Exit(0)
+ }
+
+ printEnv()
+
+ cleanFunc, err := pushgw.Initialize(*configDir, *cryptoKey)
+ if err != nil {
+ log.Fatalln("failed to initialize:", err)
+ }
+
+ code := 1
+ sc := make(chan os.Signal, 1)
+ signal.Notify(sc, syscall.SIGHUP, syscall.SIGINT, syscall.SIGTERM, syscall.SIGQUIT)
+
+EXIT:
+ for {
+ sig := <-sc
+ fmt.Println("received signal:", sig.String())
+ switch sig {
+ case syscall.SIGQUIT, syscall.SIGTERM, syscall.SIGINT:
+ code = 0
+ break EXIT
+ case syscall.SIGHUP:
+ // reload configuration?
+ default:
+ break EXIT
+ }
+ }
+
+ cleanFunc()
+ fmt.Println("process exited")
+ os.Exit(code)
+}
+
+func printEnv() {
+ runner.Init()
+ fmt.Println("runner.cwd:", runner.Cwd)
+ fmt.Println("runner.hostname:", runner.Hostname)
+ fmt.Println("runner.fd_limits:", runner.FdLimits())
+ fmt.Println("runner.vm_limits:", runner.VMLimits())
+}
diff --git a/conf/conf.go b/conf/conf.go
new file mode 100644
index 0000000000000000000000000000000000000000..aa47e14885e6d997b5cab54a964d86f3e2c07a47
--- /dev/null
+++ b/conf/conf.go
@@ -0,0 +1,80 @@
+package conf
+
+import (
+ "fmt"
+ "os"
+ "strings"
+
+ "github.com/ccfos/nightingale/v6/alert/aconf"
+ "github.com/ccfos/nightingale/v6/center/cconf"
+ "github.com/ccfos/nightingale/v6/pkg/cfg"
+ "github.com/ccfos/nightingale/v6/pkg/httpx"
+ "github.com/ccfos/nightingale/v6/pkg/logx"
+ "github.com/ccfos/nightingale/v6/pkg/ormx"
+ "github.com/ccfos/nightingale/v6/pushgw/pconf"
+ "github.com/ccfos/nightingale/v6/storage"
+)
+
+type ConfigType struct {
+ Global GlobalConfig
+ Log logx.Config
+ HTTP httpx.Config
+ DB ormx.DBConfig
+ Redis storage.RedisConfig
+
+ Pushgw pconf.Pushgw
+ Alert aconf.Alert
+ Center cconf.Center
+}
+
+type GlobalConfig struct {
+ RunMode string
+}
+
+func InitConfig(configDir, cryptoKey string) (*ConfigType, error) {
+ var config = new(ConfigType)
+
+ if err := cfg.LoadConfigByDir(configDir, config); err != nil {
+ return nil, fmt.Errorf("failed to load configs of directory: %s error: %s", configDir, err)
+ }
+
+ config.Pushgw.PreCheck()
+ config.Alert.PreCheck()
+ config.Center.PreCheck()
+
+ err := decryptConfig(config, cryptoKey)
+ if err != nil {
+ return nil, err
+ }
+
+ if config.Pushgw.DatasourceId == 0 {
+ return nil, fmt.Errorf("datasourceId is 0")
+ }
+
+ if config.Alert.Heartbeat.IP == "" {
+ // auto detect
+ // config.Alert.Heartbeat.IP = fmt.Sprint(GetOutboundIP())
+ // 自动获取IP在有些环境下容易出错，这里用hostname+pid来作唯一标识
+
+ hostname, err := os.Hostname()
+ if err != nil {
+ fmt.Println("failed to get hostname:", err)
+ os.Exit(1)
+ }
+
+ if strings.Contains(hostname, "localhost") {
+ fmt.Println("Warning! hostname contains substring localhost, setting a more unique hostname is recommended")
+ }
+
+ config.Alert.Heartbeat.IP = hostname
+
+ // if config.Alert.Heartbeat.IP == "" {
+ // fmt.Println("heartbeat ip auto got is blank")
+ // os.Exit(1)
+ // }
+ }
+
+ config.Alert.Heartbeat.Endpoint = fmt.Sprintf("%s:%d", config.Alert.Heartbeat.IP, config.HTTP.Port)
+
+ return config, nil
+}
diff --git a/conf/crypto.go b/conf/crypto.go
new file mode 100644
index 0000000000000000000000000000000000000000..4e636da63f15d8e93384ed4487f7e2daddcc001c
--- /dev/null
+++ b/conf/crypto.go
@@ -0,0 +1,36 @@
+package conf
+
+import (
+ "fmt"
+
+ "github.com/ccfos/nightingale/v6/pkg/secu"
+)
+
+func decryptConfig(config *ConfigType, cryptoKey string) error {
+ decryptDsn, err := secu.DealWithDecrypt(config.DB.DSN, cryptoKey)
+ if err != nil {
+ return fmt.Errorf("failed to decrypt the db dsn: %s", err)
+ }
+
+ config.DB.DSN = decryptDsn
+
+ for k := range config.HTTP.BasicAuth {
+ decryptPwd, err := secu.DealWithDecrypt(config.HTTP.BasicAuth[k], cryptoKey)
+ if err != nil {
+ return fmt.Errorf("failed to decrypt http basic auth password: %s", err)
+ }
+
+ config.HTTP.BasicAuth[k] = decryptPwd
+ }
+
+ for i, v := range config.Pushgw.Writers {
+ decryptWriterPwd, err := secu.DealWithDecrypt(v.BasicAuthPass, cryptoKey)
+ if err != nil {
+ return fmt.Errorf("failed to decrypt writer basic auth password: %s", err)
+ }
+
+ config.Pushgw.Writers[i].BasicAuthPass = decryptWriterPwd
+ }
+
+ return nil
+}
diff --git a/docker/.dockerignore b/docker/.dockerignore
deleted file mode 100644
index 128291fa3b7a450373168f0a3c44128b7411000e..0000000000000000000000000000000000000000
--- a/docker/.dockerignore
+++ /dev/null
@@ -1,7 +0,0 @@
-ibexetc
-initsql
-mysqletc
-n9eetc
-prometc
-build.sh
-docker-compose.yaml
diff --git a/docker/Dockerfile b/docker/Dockerfile
deleted file mode 100644
index 39d449b015085003e7626c2f8d289564421f0e1c..0000000000000000000000000000000000000000
--- a/docker/Dockerfile
+++ /dev/null
@@ -1,15 +0,0 @@
-FROM python:2.7.8-slim
-#FROM python:2
-#FROM ubuntu:21.04
-
-WORKDIR /app
-ADD n9e /app
-ADD http://download.flashcat.cloud/wait /wait
-RUN mkdir -p /app/pub && chmod +x /wait
-ADD pub /app/pub/
-RUN chmod +x n9e
-
-EXPOSE 19000
-EXPOSE 18000
-
-CMD ["/app/n9e", "-h"]
diff --git a/docker/Dockerfile.goreleaser b/docker/Dockerfile.goreleaser
deleted file mode 100644
index cf25f56f01f0bfde3434d57febd5a5196c9cc338..0000000000000000000000000000000000000000
--- a/docker/Dockerfile.goreleaser
+++ /dev/null
@@ -1,14 +0,0 @@
-FROM --platform=$BUILDPLATFORM python:2.7.8-slim
-
-
-WORKDIR /app
-ADD n9e /app
-ADD http://download.flashcat.cloud/wait /wait
-RUN mkdir -p /app/pub && chmod +x /wait
-ADD pub /app/pub/
-RUN chmod +x n9e
-
-EXPOSE 19000
-EXPOSE 18000
-
-CMD ["/app/n9e", "-h"]
diff --git a/docker/build.sh b/docker/build.sh
deleted file mode 100755
index ddc9f3e78bea1329888a60794729c0e597850bb7..0000000000000000000000000000000000000000
--- a/docker/build.sh
+++ /dev/null
@@ -1,20 +0,0 @@
-#!/bin/sh
-if [ $# -ne 1 ]; then
- echo "$0 {{.RuleName}}
- -- -
-
-
- {{if .IsRecovered}}
-
-
-
- - -
- | 级别状态： | -S{{.Severity}} Recovered | -
|---|---|
| 级别状态： | -S{{.Severity}} Triggered | -
| 策略备注： | -{{.RuleNote}} | -
| 设备备注： | -{{.TargetNote}} | -
| 监控指标： | -{{.TagsJSON}} | -
| 恢复时间： | -{{timeformat .LastEvalTime}} | -
| 触发时值： | -{{.TriggerValue}} | -
| 触发时间： | -- {{timeformat .TriggerTime}} - | -
| 发送时间： | -- {{timestamp}} - | -
| PromQL： | -- {{.PromQl}} - | -
- - -