resize img of readme

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,12 @@
+---
+name: Bug Report
+about: Report a bug encountered while operating Nightingale
+labels: kind/bug
+---
+
+**夜莺版本**:
+
+
+**问题和复现方法**:
+
+

.github/ISSUE_TEMPLATE/config.yml

@@ -1,5 +1,5 @@
 blank_issues_enabled: false
 contact_links:
-  - name: Nightingale docs
-    url: https://n9e.github.io/
-    about: You may want to read through the document before asking questions.
+  - name: Nightingale community
+    url: https://n9e.didiyun.com/community/
+    about: List of communication channels for the Nightingale community.

.github/ISSUE_TEMPLATE/question.yml

@@ -1,33 +0,0 @@
-name: Bug Report & Usage Question
-description: Reporting a bug or asking a question about how to use Nightingale 
-labels: []
-
-body:
-  - type: markdown
-    attributes:
-      value: |
-        The more detailed the form is filled in, the easier the problem will be solved.
-        提供的信息越详细，问题解决的可能性就越大。另外, 提问之前请先搜索历史 issue (包括 close 的), 以免重复提问。
-  - type: textarea
-    id: question
-    attributes:
-      label: Question and Steps to reproduce
-      description: Describe your question and steps to reproduce the bug. 描述问题以及复现步骤
-    validations:
-      required: true
-  - type: textarea
-    id: logs
-    attributes:
-      label: Relevant logs and configurations
-      description: Relevant logs and configurations. 报错日志（[查看方法](https://flashcat.cloud/docs/content/flashcat-monitor/nightingale-v6/faq/how-to-check-logs/)）以及各个相关组件的配置信息
-      render: text
-    validations:
-      required: true
-  - type: textarea
-    id: system-info
-    attributes:
-      label: Version
-      description: Include nightingale version, operating system, and other relevant details. 请告知夜莺的版本、操作系统的版本、CPU架构等信息
-    validations:
-      required: true
- 

.github/workflows/n9e.yml

@@ -1,33 +1,26 @@
-name: Release
+name: Go
 
 on:
   push:
-    tags:
-      - 'v*'
-env:
-  GO_VERSION: 1.18
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
 
 jobs:
-  goreleaser:
+
+  build:
+    name: Build
     runs-on: ubuntu-latest
     steps:
-      - name: Checkout Source Code
-        uses: actions/checkout@v3
-        with:
-          fetch-depth: 0
-      - name: Setup Go Environment
-        uses: actions/setup-go@v3
-        with:
-          go-version: ${{ env.GO_VERSION }}
-      - uses: docker/login-action@v2
-        with:
-          username: ${{ secrets.DOCKERHUB_USERNAME }}
-          password: ${{ secrets.DOCKERHUB_TOKEN }}
-      - name: Run GoReleaser
-        uses: goreleaser/goreleaser-action@v3
-        with:
-          distribution: goreleaser
-          version: '~> v1'
-          args: release --rm-dist
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+    - name: Set up Go 1.17
+      uses: actions/setup-go@v1
+      with:
+        go-version: 1.17
+      id: go
+
+    - name: Check out code into the Go module directory
+      uses: actions/checkout@v2
+
+    - name: Build
+      run: make

.gitignore

@@ -30,11 +30,7 @@ _test
 /dist
 /etc/*.local.yml
 /etc/*.local.conf
-/etc/rsa/*
 /etc/plugins/*.local.yml
-/etc/script/rules.yaml
-/etc/script/alert-rules.json
-/etc/script/record-rules.json
 /data*
 /tarball
 /run
@@ -44,14 +40,7 @@ _test
 /n9e
 /docker/pub
 /docker/n9e
-/docker/compose-bridge/mysqldata
-/docker/compose-host-network/mysqldata
-/docker/compose-host-network-metric-log/mysqldata
-/docker/compose-host-network-metric-log/n9e-logs
-/docker/compose-postgres/pgdata
-/etc.local*
-/front/statik/statik.go
-/docker/compose-bridge/etc-nightingale/rsa/
+/docker/mysqldata
 
 .alerts
 .idea
@@ -63,4 +52,4 @@ _test
 queries.active
 
 /n9e-*
-n9e.sql
+

.goreleaser.yaml

@@ -1,122 +0,0 @@
-before:
-  hooks:
-    # You may remove this if you don't use go modules.
-    - go mod tidy
-    - go install github.com/rakyll/statik
-
-snapshot:
-  name_template: '{{ .Tag }}'
-checksum:
-  name_template: 'checksums.txt'
-changelog:
-  skip: true
-
-builds:
-  - id: build
-    hooks:
-      pre:
-      - cmd: sh -x ./fe.sh
-        output: true
-    main: ./cmd/center/
-    binary: n9e
-    env:
-      - CGO_ENABLED=0
-    goos:
-      - linux
-    goarch:
-      - amd64
-      - arm64
-    ldflags:
-      - -s -w
-      - -X github.com/ccfos/nightingale/v6/pkg/version.Version={{ .Tag }}-{{.Commit}}
-  - id: build-cli
-    main: ./cmd/cli/
-    binary: n9e-cli
-    env:
-      - CGO_ENABLED=0
-    goos:
-      - linux
-    goarch:
-      - amd64
-      - arm64
-    ldflags:
-      - -s -w
-      - -X github.com/ccfos/nightingale/v6/pkg/version.Version={{ .Tag }}-{{.Commit}}
-  - id: build-edge
-    main: ./cmd/edge/
-    binary: n9e-edge
-    env:
-      - CGO_ENABLED=0
-    goos:
-      - linux
-    goarch:
-      - amd64
-      - arm64
-    ldflags:
-      - -s -w
-      - -X github.com/ccfos/nightingale/v6/pkg/version.Version={{ .Tag }}-{{.Commit}}
-
-archives:
-  - id: n9e
-    builds:
-      - build
-      - build-cli
-      - build-edge
-    format: tar.gz
-    format_overrides:
-      - goos: windows
-        format: zip
-    name_template: "n9e-v{{ .Version }}-{{ .Os }}-{{ .Arch }}"
-    wrap_in_directory: false
-    files:
-      - docker/*
-      - etc/*
-      - integrations/*
-      - cli/*
-      - n9e.sql
-
-release:
-  github:
-    owner: ccfos
-    name: nightingale
-  name_template: "v{{ .Version }}"
-
-dockers:
-  - image_templates:
-      - flashcatcloud/nightingale:{{ .Version }}-amd64
-    goos: linux
-    goarch: amd64
-    ids:
-      - build
-    dockerfile: docker/Dockerfile.goreleaser
-    extra_files:
-      - etc
-      - integrations
-    use: buildx
-    build_flag_templates:
-      - "--platform=linux/amd64"
-  - image_templates:
-      - flashcatcloud/nightingale:{{ .Version }}-arm64v8
-    goos: linux
-    goarch: arm64
-    ids:
-      - build
-    dockerfile: docker/Dockerfile.goreleaser.arm64
-    extra_files:
-      - etc
-      - integrations
-    use: buildx
-    build_flag_templates:
-      - "--platform=linux/arm64/v8"
-
-docker_manifests:
-
-  - name_template: flashcatcloud/nightingale:{{ .Version }}
-    image_templates:
-      - flashcatcloud/nightingale:{{ .Version }}-amd64
-      - flashcatcloud/nightingale:{{ .Version }}-arm64v8
-
-  - name_template: flashcatcloud/nightingale:latest
-    image_templates:
-      - flashcatcloud/nightingale:{{ .Version }}-amd64
-      - flashcatcloud/nightingale:{{ .Version }}-arm64v8

LICENSE

@@ -430,4 +430,4 @@ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  
 See the License for the specific language governing permissions and
  
-limitations under the License.
+limitations under the License.

Makefile

@@ -1,41 +1,42 @@
-.PHONY: prebuild build
+.PHONY: start build
 
-ROOT:=$(shell pwd -P)
-GIT_COMMIT:=$(shell git --work-tree ${ROOT}  rev-parse 'HEAD^{commit}')
-_GIT_VERSION:=$(shell git --work-tree ${ROOT} describe --tags --abbrev=14 "${GIT_COMMIT}^{commit}" 2>/dev/null)
-TAG=$(shell echo "${_GIT_VERSION}" |  awk -F"-" '{print $$1}')
-RELEASE_VERSION:="$(TAG)-$(GIT_COMMIT)"
+NOW = $(shell date -u '+%Y%m%d%I%M%S')
 
-all: prebuild build
+RELEASE_VERSION = 5.5.0
 
-prebuild:
-	echo "begin download and embed the front-end file..."
-	sh fe.sh
-	echo "front-end file download and embedding completed."
+APP 			= n9e
+SERVER_BIN  	= $(APP)
+# RELEASE_ROOT 	= release
+# RELEASE_SERVER 	= release/${APP}
+# GIT_COUNT 		= $(shell git rev-list --all --count)
+# GIT_HASH        = $(shell git rev-parse --short HEAD)
+# RELEASE_TAG     = $(RELEASE_VERSION).$(GIT_COUNT).$(GIT_HASH)
+
+all: build
 
 build:
-	go build -ldflags "-w -s -X github.com/ccfos/nightingale/v6/pkg/version.Version=$(RELEASE_VERSION)" -o n9e ./cmd/center/main.go
+	go build -ldflags "-w -s -X main.VERSION=$(RELEASE_VERSION)" -o $(SERVER_BIN) ./src
 
-build-edge:
-	go build -ldflags "-w -s -X github.com/ccfos/nightingale/v6/pkg/version.Version=$(RELEASE_VERSION)" -o n9e-edge ./cmd/edge/
+# start:
+# 	@go run -ldflags "-X main.VERSION=$(RELEASE_TAG)" ./cmd/${APP}/main.go web -c ./configs/config.toml -m ./configs/model.conf --menu ./configs/menu.yaml
+run_webapi:
+	nohup ./n9e webapi > webapi.log 2>&1 &
 
-build-alert:
-	go build -ldflags "-w -s -X github.com/ccfos/nightingale/v6/pkg/version.Version=$(RELEASE_VERSION)" -o n9e-alert ./cmd/alert/main.go
+run_server:
+	nohup ./n9e server > server.log 2>&1 &
 
-build-pushgw:
-	go build -ldflags "-w -s -X github.com/ccfos/nightingale/v6/pkg/version.Version=$(RELEASE_VERSION)" -o n9e-pushgw ./cmd/pushgw/main.go
+# swagger:
+# 	@swag init --parseDependency --generalInfo ./cmd/${APP}/main.go --output ./internal/app/swagger
 
-build-cli: 
-	go build -ldflags "-w -s -X github.com/ccfos/nightingale/v6/pkg/version.Version=$(RELEASE_VERSION)" -o n9e-cli ./cmd/cli/main.go
+# wire:
+# 	@wire gen ./internal/app
 
-run:
-	nohup ./n9e > n9e.log 2>&1 &
+# test:
+# 	cd ./internal/app/test && go test -v
 
-run-alert:
-	nohup ./n9e-alert > n9e-alert.log 2>&1 &
+# clean:
+# 	rm -rf data release $(SERVER_BIN) internal/app/test/data cmd/${APP}/data
 
-run-pushgw:
-	nohup ./n9e-pushgw > n9e-pushgw.log 2>&1 &
-
-release:
-	goreleaser --skip-validate --skip-publish --snapshot
+pack: build
+	rm -rf $(APP)-$(RELEASE_VERSION).tar.gz
+	tar -zcvf $(APP)-$(RELEASE_VERSION).tar.gz docker etc $(SERVER_BIN) pub/font pub/index.html pub/assets pub/image

README.md

@@ -1,100 +1,84 @@
-<p align="center">
-  <a href="https://github.com/ccfos/nightingale">
-    <img src="doc/img/Nightingale_L_V.png" alt="nightingale - cloud native monitoring" width="100" /></a>
-</p>
-<p align="center">
-  <b>开源告警管理专家 一体化的可观测平台</b>
-</p>
+## 介绍
 
-<p align="center">
-<a href="https://flashcat.cloud/docs/">
-  <img alt="Docs" src="https://img.shields.io/badge/docs-get%20started-brightgreen"/></a>
-<a href="https://hub.docker.com/u/flashcatcloud">
-  <img alt="Docker pulls" src="https://img.shields.io/docker/pulls/flashcatcloud/nightingale"/></a>
-<a href="https://github.com/ccfos/nightingale/graphs/contributors">
-  <img alt="GitHub contributors" src="https://img.shields.io/github/contributors-anon/ccfos/nightingale"/></a>
-<img alt="GitHub Repo stars" src="https://img.shields.io/github/stars/ccfos/nightingale">
-<img alt="GitHub forks" src="https://img.shields.io/github/forks/ccfos/nightingale">
-<br/><img alt="GitHub Repo issues" src="https://img.shields.io/github/issues/ccfos/nightingale">
-<img alt="GitHub Repo issues closed" src="https://img.shields.io/github/issues-closed/ccfos/nightingale">
-<img alt="GitHub latest release" src="https://img.shields.io/github/v/release/ccfos/nightingale"/>
-<img alt="License" src="https://img.shields.io/badge/license-Apache--2.0-blue"/>
-<a href="https://n9e-talk.slack.com/">
-  <img alt="GitHub contributors" src="https://img.shields.io/badge/join%20slack-%23n9e-brightgreen.svg"/></a>
-</p>
+> Nightingale is an enterprise-level cloud-native monitoring system, which can be used as drop-in replacement of Prometheus for alerting and management.
+>
+>夜莺是一款开源的云原生监控系统，采用 All-In-One 的设计，提供企业级的功能特性，开箱即用的产品体验。推荐升级您的 `Prometheus` + `AlertManager` + `Grafana` 组合方案到夜莺。
+
+- 内置丰富的Dashboard、好用实用的告警管理、自定义视图、故障自愈；
+- Dashboard和告警策略支持一键导入，详细的指标分类和解释；
+- 支持多 Prometheus 数据源管理，以一个集中的视图来管理所有的告警和dashboard；
+- 支持 Prometheus、M3DB、VictoriaMetrics、Influxdb、TDEngine 等多种时序库作为存储方案；
+- 原生支持 PromQL；
+- 支持 Exporter 作为数据采集方案；
+- 支持 Telegraf 作为监控数据采集方案；
+- 支持对接 Grafana 作为补充可视化方案；
 
 
+#### 如果您在使用 Prometheus 过程中，有以下的一个或者多个需求场景，推荐您升级到夜莺：
 
-[English](./README_en.md) | [中文](./README.md)
+- Prometheus、Alertmanager、Grafana 等多个系统较为割裂，缺乏统一视图，无法开箱即用;
+- 通过修改配置文件来管理 Prometheus、Alertmanager 的方式，学习曲线大，协同有难度;
+- 数据量过大而无法扩展您的 Prometheus 集群；
+- 生产环境运行多套 Prometheus 集群，面临管理和使用成本高的问题；
 
-## 夜莺 Nightingale 是什么
+#### 如果您在使用Zabbix，有以下的场景，推荐您升级到夜莺：
 
-夜莺监控是一款开源云原生观测分析工具，采用 All-in-One 的设计理念，集数据采集、可视化、监控告警、数据分析于一体，与云原生生态紧密集成，提供开箱即用的企业级监控分析和告警能力。夜莺于 2020 年 3 月 20 日，在 github 上发布 v1 版本，已累计迭代 100 多个版本。
-
-夜莺最初由滴滴开发和开源，并于 2022 年 5 月 11 日，捐赠予中国计算机学会开源发展委员会（CCF ODC），为 CCF ODC 成立后接受捐赠的第一个开源项目。夜莺的核心研发团队，也是 Open-Falcon 项目原核心研发人员，从 2014 年（Open-Falcon 是 2014 年开源）算起来，也有 10 年了，只为把监控这个事情做好。
+- 监控的数据量太大，希望有更好的扩展解决方案；
+- 学习曲线高，多人多团队模式下，希望有更好的协同使用效率；
+- 微服务和云原生架构下，监控数据的生命周期多变、监控数据维度基数高，Zabbix数据模型不易适配；
 
 
-## 快速开始
-- 👉[文档中心](https://flashcat.cloud/docs/) | [下载中心](https://flashcat.cloud/download/nightingale/)
-- ❤️[报告 Bug](https://github.com/ccfos/nightingale/issues/new?assignees=&labels=&projects=&template=question.yml)
-- ℹ️为了提供更快速的访问体验，上述文档和下载站点托管于 [FlashcatCloud](https://flashcat.cloud)
+#### 如果您在使用[open-falcon](https://github.com/open-falcon/falcon-plus)，我们更推荐您升级到夜莺：
+- 关于open-falcon和夜莺的详细介绍，请参考阅读[云原生监控的十个特点和趋势](https://mp.weixin.qq.com/s?__biz=MzkzNjI5OTM5Nw==&mid=2247483738&idx=1&sn=e8bdbb974a2cd003c1abcc2b5405dd18&chksm=c2a19fb0f5d616a63185cd79277a79a6b80118ef2185890d0683d2bb20451bd9303c78d083c5#rd)。
 
-## 功能特点
+## 快速安装部署
+- [n9e.github.io/quickstart](https://n9e.github.io/quickstart/)
 
-- 对接多种时序库：支持对接 Prometheus、VictoriaMetrics、Thanos、Mimir、M3DB、TDengine 等多种时序库，实现统一告警管理。
-- 专业告警能力：内置支持多种告警规则，可以扩展支持常见通知媒介，支持告警屏蔽/抑制/订阅/自愈、告警事件管理。
-- 高性能可视化引擎：支持多种图表样式，内置众多 Dashboard 模版，也可导入 Grafana 模版，开箱即用，开源协议商业友好。
-- 支持常见采集器：支持 [Categraf](https://flashcat.cloud/product/categraf)、Telegraf、Grafana-agent、Datadog-agent、各种 Exporter 作为采集器，没有什么数据是不能监控的。
-- 👀无缝搭配 [Flashduty](https://flashcat.cloud/product/flashcat-duty/)：实现告警聚合收敛、认领、升级、排班、IM集成，确保告警处理不遗漏，减少打扰，高效协同。
+## 详细文档
+- [n9e.github.io](https://n9e.github.io/)
+
+## 产品演示
+#### 您可以直接导入并生成 MySQL 相关的告警策略：
+<img src="doc/img/mysql-alerts.png" width="680">
+
+#### 您可以直接导入并生成主机相关的 dashboard：
+<img src="doc/img/n9e-node-dashboard.png" width="680">
+
+#### 您也可以在夜莺中方便的查看所有活跃的告警以及历史告警：
+<img src="https://n9e.github.io/intro/alert-events.png" width="680">
+
+## 系统架构
+#### 一个典型的 Nightingale 部署架构:
+<img src="https://n9e.github.io/intro/arch-system.png" width="680">
+
+#### 使用 VictoriaMetrics 作为时序数据库的典型部署架构:
+<img src="https://n9e.github.io/fc-monitoring-vm.png" width="680">
 
 
-## 截图演示
+## 联系我们和反馈问题
+- 我们推荐您优先使用[github issue](https://github.com/didi/nightingale/issues)作为首选问题反馈和需求提交的通道；
+- 您可以加入我们的微信群组——[Nightingale 微信群组](https://s3-gz01.didistatic.com/n9e-pub/image/n9e-wx.png)；
+- 当然，推荐您关注夜莺监控公众号，及时获取相关产品动态 
 
-即时查询，类似 Prometheus 内置的查询分析页面，做 ad-hoc 查询，夜莺做了一些 UI 优化，同时提供了一些内置 promql 指标，让不太了解 promql 的用户也可以快速查询。
-
-![即时查询](https://download.flashcat.cloud/ulric/20240513103305.png)
-
-当然，也可以直接通过指标视图查看，有了指标视图，即时查询基本可以不用了，或者只有高端玩家使用即时查询，普通用户直接通过指标视图查询即可。
-
-![指标视图](https://download.flashcat.cloud/ulric/20240513103530.png)
-
-夜莺内置了常用仪表盘，可以直接导入使用。也可以导入 Grafana 仪表盘，不过只能兼容 Grafana 基本图表，如果已经习惯了 Grafana 建议继续使用 Grafana 看图，把夜莺作为一个告警引擎使用。
-
-![内置仪表盘](https://download.flashcat.cloud/ulric/20240513103628.png)
-
-除了内置的仪表盘，也内置了很多告警规则，开箱即用。
-
-![内置告警规则](https://download.flashcat.cloud/ulric/20240513103825.png)
+<img src="https://n9e.github.io/cloudmon.png" width="180">
 
 
+## 参与到夜莺开源项目和社区
+我们欢迎您以各种方式参与到夜莺开源项目和开源社区中来，工作包括不限于：
+- 反馈使用中遇到的问题和Bug => [github issue](https://github.com/didi/nightingale/issues)
+- 补充和完善文档 => [n9e.github.io](https://n9e.github.io/)
+- 分享您在使用夜莺监控过程中的最佳实践和经验心得 => [夜莺User Story](https://github.com/didi/nightingale/issues/897)
+- 参与我们的社区活动 => [Nightingale 微信群组](https://s3-gz01.didistatic.com/n9e-pub/image/n9e-wx.png)
+- 提交代码，让夜莺监控更快、更稳、更好用 =>[github PR](https://github.com/didi/nightingale/pulls)
 
-## 产品架构
-
-社区使用夜莺最多的场景就是使用夜莺做告警引擎，对接多套时序库，统一告警规则管理。绘图仍然使用 Grafana 居多。作为一个告警引擎，夜莺的产品架构如下：
-
-![产品架构](https://download.flashcat.cloud/ulric/20240221152601.png)
-
-对于个别边缘机房，如果和中心夜莺服务端网络链路不好，希望提升告警可用性，我们也提供边缘机房告警引擎下沉部署模式，这个模式下，即便网络割裂，告警功能也不受影响。
-
-![边缘部署模式](https://download.flashcat.cloud/ulric/20240222102119.png)
-
-
-## 交流渠道
-- 报告Bug，优先推荐提交[夜莺GitHub Issue](https://github.com/ccfos/nightingale/issues/new?assignees=&labels=kind%2Fbug&projects=&template=bug_report.yml)
-- 推荐完整浏览[夜莺文档站点](https://flashcat.cloud/docs/content/flashcat-monitor/nightingale-v7/introduction/)，了解更多信息
-- 推荐搜索关注夜莺公众号，第一时间获取社区动态：`夜莺监控Nightingale`
-- 日常问题交流推荐加入[知识星球](https://download.flashcat.cloud/ulric/20240319095409.png)，也可以加我微信 `picobyte`，备注：`夜莺加群-<公司>-<姓名>` 拉入微信群，不过研发人员主要是关注 github issue 和星球，微信群关注较少
-
-## 广受关注
-[![Stargazers over time](https://api.star-history.com/svg?repos=ccfos/nightingale&type=Date)](https://star-history.com/#ccfos/nightingale&Date)
-
-
-## 社区共建
-- ❇️请阅读浏览[夜莺开源项目和社区治理架构草案](./doc/community-governance.md)，真诚欢迎每一位用户、开发者、公司以及组织，使用夜莺监控、积极反馈 Bug、提交功能需求、分享最佳实践，共建专业、活跃的夜莺开源社区。
-- 夜莺贡献者❤️
-<a href="https://github.com/ccfos/nightingale/graphs/contributors">
-  <img src="https://contrib.rocks/image?repo=ccfos/nightingale" />
-</a>
+## TODO
+- [x] deploy nightingale in docker
+- [x] export /metrics endpoint
+- [x] notify.py support feishu
+- [ ] notify.py support sms
+- [ ] notify.py support voice
+- [x] support remote write api
+- [ ] support pushgateway api
 
 ## License
-- [Apache License V2.0](https://github.com/didi/nightingale/blob/main/LICENSE)
+夜莺监控，采用[Apache License V2.0](https://github.com/didi/nightingale/blob/main/LICENSE)开源许可证。

README_en.md

@@ -1,104 +0,0 @@
-<p align="center">
-  <a href="https://github.com/ccfos/nightingale">
-    <img src="doc/img/Nightingale_L_V.png" alt="nightingale - cloud native monitoring" width="240" /></a>
-</p>
-
-<p align="center">
-<img alt="GitHub latest release" src="https://img.shields.io/github/v/release/ccfos/nightingale"/>
-<a href="https://n9e.github.io">
-  <img alt="Docs" src="https://img.shields.io/badge/docs-get%20started-brightgreen"/></a>
-<a href="https://hub.docker.com/u/flashcatcloud">
-  <img alt="Docker pulls" src="https://img.shields.io/docker/pulls/flashcatcloud/nightingale"/></a>
-<img alt="GitHub Repo stars" src="https://img.shields.io/github/stars/ccfos/nightingale">
-<img alt="GitHub Repo issues" src="https://img.shields.io/github/issues/ccfos/nightingale">
-<img alt="GitHub Repo issues closed" src="https://img.shields.io/github/issues-closed/ccfos/nightingale">
-<img alt="GitHub forks" src="https://img.shields.io/github/forks/ccfos/nightingale">
-<a href="https://github.com/ccfos/nightingale/graphs/contributors">
-  <img alt="GitHub contributors" src="https://img.shields.io/github/contributors-anon/ccfos/nightingale"/></a>
-<a href="https://n9e-talk.slack.com/">
-  <img alt="GitHub contributors" src="https://img.shields.io/badge/join%20slack-%23n9e-brightgreen.svg"/></a>
-<img alt="License" src="https://img.shields.io/badge/license-Apache--2.0-blue"/>
-</p>
-<p align="center">
-  An open-source cloud-native monitoring system that is <b>all-in-one</b> <br/>
-  <b>Out-of-the-box</b>, it integrates data collection, visualization, and monitoring alert <br/>
-  We recommend upgrading your <b>Prometheus + AlertManager + Grafana</b> combination to Nightingale!
-</p>
-
-[English](./README_en.md) | [中文](./README.md)
-
-
-## Highlighted Features
-
-- **Out-of-the-box**
-  - Supports multiple deployment methods such as **Docker, Helm Chart, and cloud services**, integrates data collection, monitoring, and alerting into one system, and comes with various monitoring dashboards, quick views, and alert rule templates. **It greatly reduces the construction cost, learning cost, and usage cost of cloud-native monitoring systems**.
-- **Professional Alerting**
-  - Provides visual alert configuration and management, supports various alert rules, offers the ability to configure silence and subscription rules, supports multiple alert delivery channels, and has features such as alert self-healing and event management.
-- **Cloud-Native**
-  - Quickly builds an enterprise-level cloud-native monitoring system through a turnkey approach, supports multiple collectors such as [Categraf](https://github.com/flashcatcloud/categraf), Telegraf, and Grafana-agent, supports multiple data sources such as Prometheus, VictoriaMetrics, M3DB, ElasticSearch, and Jaeger, and is compatible with importing Grafana dashboards. **It seamlessly integrates with the cloud-native ecosystem**.
-- **High Performance and High Availability**
-  - Due to the multi-data-source management engine of Nightingale and its excellent architecture design, and utilizing a high-performance time-series database, it can handle data collection, storage, and alert analysis scenarios with billions of time-series data, saving a lot of costs.
-  - Nightingale components can be horizontally scaled with no single point of failure. It has been deployed in thousands of enterprises and tested in harsh production practices. Many leading Internet companies have used Nightingale for cluster machines with hundreds of nodes, processing billions of time-series data.
-- **Flexible Extension and Centralized Management**
-  - Nightingale can be deployed on a 1-core 1G cloud host, deployed in a cluster of hundreds of machines, or run in Kubernetes. Time-series databases, alert engines, and other components can also be decentralized to various data centers and regions, balancing edge deployment with centralized management. **It solves the problem of data fragmentation and lack of unified views**.
-
-
-#### If you are using Prometheus and have one or more of the following requirement scenarios, it is recommended that you upgrade to Nightingale:
-
-- Multiple systems such as Prometheus, Alertmanager, Grafana, etc. are fragmented and lack a unified view and cannot be used out of the box;
-- The way to manage Prometheus and Alertmanager by modifying configuration files has a big learning curve and is difficult to collaborate;
-- Too much data to scale-up your Prometheus cluster;
-- Multiple Prometheus clusters running in production environments, which faced high management and usage costs;
-
-#### If you are using Zabbix and have the following scenarios, it is recommended that you upgrade to Nightingale:
-
-- Monitoring too much data and wanting a better scalable solution;
-- A high learning curve and a desire for better efficiency of collaborative use in a multi-person, multi-team model;
-- Microservice and cloud-native architectures with variable monitoring data lifecycles and high monitoring data dimension bases, which are not easily adaptable to the Zabbix data model;
-
-
-#### If you are using [open-falcon](https://github.com/open-falcon/falcon-plus), we recommend you to upgrade to Nightingale：
-- For more information about open-falcon and Nightingale, please refer to read [Ten features and trends of cloud-native monitoring](https://mp.weixin.qq.com/s?__biz=MzkzNjI5OTM5Nw==&mid=2247483738&idx=1&sn=e8bdbb974a2cd003c1abcc2b5405dd18&chksm=c2a19fb0f5d616a63185cd79277a79a6b80118ef2185890d0683d2bb20451bd9303c78d083c5#rd)。
-
-## Getting Started
-
-[https://n9e.github.io/](https://n9e.github.io/)
-
-## Screenshots
-
-https://user-images.githubusercontent.com/792850/216888712-2565fcea-9df5-47bd-a49e-d60af9bd76e8.mp4
-
-## Architecture
-
-<img src="doc/img/arch-product.png" width="600">
-
-Nightingale monitoring can receive monitoring data reported by various collectors (such as [Categraf](https://github.com/flashcatcloud/categraf) , telegraf, grafana-agent, Prometheus, etc.) and write them to various popular time-series databases (such as Prometheus, M3DB, VictoriaMetrics, Thanos, TDEngine, etc.). It provides configuration capabilities for alert rules, silence rules, and subscription rules, as well as the ability to view monitoring data. It also provides automatic alarm self-healing mechanisms (such as automatically calling back to a webhook address or executing a script after an alarm is triggered), and the ability to store and manage historical alarm events and view them in groups.
-
-If the performance of a standalone time-series database (such as Prometheus) has bottlenecks or poor disaster recovery, we recommend using [VictoriaMetrics](https://github.com/VictoriaMetrics/VictoriaMetrics). The VictoriaMetrics architecture is relatively simple, has excellent performance, and is easy to deploy and maintain. The architecture diagram is as shown above. For more detailed documentation on VictoriaMetrics, please refer to its [official website](https://victoriametrics.com/).
-
-**We welcome you to participate in the Nightingale open-source project and community in various ways, including but not limited to**：
-- Adding and improving documentation => [n9e.github.io](https://n9e.github.io/)
-- Sharing your best practices and experience in using Nightingale monitoring => [Article sharing]((https://n9e.github.io/docs/prologue/share/))
-- Submitting product suggestions => [github issue](https://github.com/ccfos/nightingale/issues/new?assignees=&labels=kind%2Ffeature&template=enhancement.md)
-- Submitting code to make Nightingale monitoring faster, more stable, and easier to use => [github pull request](https://github.com/didi/nightingale/pulls)
-
-
-**Respecting, recognizing, and recording the work of every contributor** is the first guiding principle of the Nightingale open-source community. We advocate effective questioning, which not only respects the developer's time but also contributes to the accumulation of knowledge in the entire community
-- Before asking a question, please first refer to the [FAQ](https://www.gitlink.org.cn/ccfos/nightingale/wiki/faq) 
-- We use [GitHub Discussions](https://github.com/ccfos/nightingale/discussions) as the communication forum. You can search and ask questions here.
-- We also recommend that you join ours [Slack channel](https://n9e-talk.slack.com/) to exchange experiences with other Nightingale users.
-
-
-## Who is using Nightingale
-You can register your usage and share your experience by posting on **[Who is Using Nightingale](https://github.com/ccfos/nightingale/issues/897)**.
-
-## Stargazers over time
-[![Stargazers over time](https://starchart.cc/ccfos/nightingale.svg)](https://starchart.cc/ccfos/nightingale)
-
-## Contributors
-<a href="https://github.com/ccfos/nightingale/graphs/contributors">
-  <img src="https://contrib.rocks/image?repo=ccfos/nightingale" />
-</a>
-
-## License
-[Apache License V2.0](https://github.com/didi/nightingale/blob/main/LICENSE)

alert/aconf/conf.go

@@ -1,70 +0,0 @@
-package aconf
-
-import (
-	"path"
-)
-
-type Alert struct {
-	Disable     bool
-	EngineDelay int64
-	Heartbeat   HeartbeatConfig
-	Alerting    Alerting
-}
-
-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
-	EngineName string
-}
-
-type Alerting struct {
-	Timeout           int64
-	TemplatesDir      string
-	NotifyConcurrency int
-	WebhookBatchSend  bool
-}
-
-type CallPlugin struct {
-	Enable     bool
-	PluginPath string
-	Caller     string
-}
-
-type RedisPub struct {
-	Enable        bool
-	ChannelPrefix string
-	ChannelKey    string
-}
-
-func (a *Alert) PreCheck(configDir string) {
-	if a.Alerting.TemplatesDir == "" {
-		a.Alerting.TemplatesDir = path.Join(configDir, "template")
-	}
-
-	if a.Alerting.NotifyConcurrency == 0 {
-		a.Alerting.NotifyConcurrency = 10
-	}
-
-	if a.Heartbeat.Interval == 0 {
-		a.Heartbeat.Interval = 1000
-	}
-
-	if a.Heartbeat.EngineName == "" {
-		a.Heartbeat.EngineName = "default"
-	}
-
-	if a.EngineDelay == 0 {
-		a.EngineDelay = 30
-	}
-}

alert/alert.go

@@ -1,116 +0,0 @@
-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/dumper"
-	"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"
-	"github.com/ccfos/nightingale/v6/tdengine"
-
-	"github.com/flashcatcloud/ibex/src/cmd/ibex"
-)
-
-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
-	}
-
-	ctx := ctx.NewContext(context.Background(), nil, false, config.CenterApi)
-
-	var redis storage.Redis
-	redis, err = storage.NewRedis(config.Redis)
-	if err != nil {
-		return nil, err
-	}
-
-	syncStats := memsto.NewSyncStats()
-	alertStats := astats.NewSyncStats()
-
-	configCache := memsto.NewConfigCache(ctx, syncStats, nil, "")
-	targetCache := memsto.NewTargetCache(ctx, syncStats, redis)
-	busiGroupCache := memsto.NewBusiGroupCache(ctx, syncStats)
-	alertMuteCache := memsto.NewAlertMuteCache(ctx, syncStats)
-	alertRuleCache := memsto.NewAlertRuleCache(ctx, syncStats)
-	notifyConfigCache := memsto.NewNotifyConfigCache(ctx, configCache)
-	dsCache := memsto.NewDatasourceCache(ctx, syncStats)
-	userCache := memsto.NewUserCache(ctx, syncStats)
-	userGroupCache := memsto.NewUserGroupCache(ctx, syncStats)
-	taskTplsCache := memsto.NewTaskTplCache(ctx)
-
-	promClients := prom.NewPromClient(ctx)
-	tdengineClients := tdengine.NewTdengineClient(ctx, config.Alert.Heartbeat)
-
-	externalProcessors := process.NewExternalProcessors()
-
-	Start(config.Alert, config.Pushgw, syncStats, alertStats, externalProcessors, targetCache, busiGroupCache, alertMuteCache, alertRuleCache, notifyConfigCache, taskTplsCache, dsCache, ctx, promClients, tdengineClients, userCache, userGroupCache)
-
-	r := httpx.GinEngine(config.Global.RunMode, config.HTTP)
-	rt := router.New(config.HTTP, config.Alert, alertMuteCache, targetCache, busiGroupCache, alertStats, ctx, externalProcessors)
-
-	if config.Ibex.Enable {
-		ibex.ServerStart(false, nil, redis, config.HTTP.APIForService.BasicAuth, config.Alert.Heartbeat, &config.CenterApi, r, nil, config.Ibex, config.HTTP.Port)
-	}
-
-	rt.Config(r)
-	dumper.ConfigRouter(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, notifyConfigCache *memsto.NotifyConfigCacheType, taskTplsCache *memsto.TaskTplCache, datasourceCache *memsto.DatasourceCacheType, ctx *ctx.Context,
-	promClients *prom.PromClientMap, tdendgineClients *tdengine.TdengineClientMap, userCache *memsto.UserCacheType, userGroupCache *memsto.UserGroupCacheType) {
-	alertSubscribeCache := memsto.NewAlertSubscribeCache(ctx, syncStats)
-	recordingRuleCache := memsto.NewRecordingRuleCache(ctx, syncStats)
-	targetsOfAlertRulesCache := memsto.NewTargetOfAlertRuleCache(ctx, alertc.Heartbeat.EngineName, syncStats)
-
-	go models.InitNotifyConfig(ctx, alertc.Alerting.TemplatesDir)
-
-	naming := naming.NewNaming(ctx, alertc.Heartbeat, alertStats)
-
-	writers := writer.NewWriters(pushgwc)
-	record.NewScheduler(alertc, recordingRuleCache, promClients, writers, alertStats)
-
-	eval.NewScheduler(alertc, externalProcessors, alertRuleCache, targetCache, targetsOfAlertRulesCache,
-		busiGroupCache, alertMuteCache, datasourceCache, promClients, tdendgineClients, naming, ctx, alertStats)
-
-	dp := dispatch.NewDispatch(alertRuleCache, userCache, userGroupCache, alertSubscribeCache, targetCache, notifyConfigCache, taskTplsCache, alertc.Alerting, ctx, alertStats)
-	consumer := dispatch.NewConsumer(alertc.Alerting, ctx, dp, promClients)
-
-	go dp.ReloadTpls()
-	go consumer.LoopConsume()
-
-	go queue.ReportQueueSize(alertStats)
-	go sender.InitEmailSender(notifyConfigCache)
-}

alert/astats/stats.go

@@ -1,153 +0,0 @@
-package astats
-
-import (
-	"github.com/prometheus/client_golang/prometheus"
-)
-
-const (
-	namespace = "n9e"
-	subsystem = "alert"
-)
-
-type Stats struct {
-	AlertNotifyTotal            *prometheus.CounterVec
-	AlertNotifyErrorTotal       *prometheus.CounterVec
-	CounterAlertsTotal          *prometheus.CounterVec
-	GaugeAlertQueueSize         prometheus.Gauge
-	CounterRuleEval             *prometheus.CounterVec
-	CounterQueryDataErrorTotal  *prometheus.CounterVec
-	CounterQueryDataTotal       *prometheus.CounterVec
-	CounterRecordEval           *prometheus.CounterVec
-	CounterRecordEvalErrorTotal *prometheus.CounterVec
-	CounterMuteTotal            *prometheus.CounterVec
-	CounterRuleEvalErrorTotal   *prometheus.CounterVec
-	CounterHeartbeatErrorTotal  *prometheus.CounterVec
-	CounterSubEventTotal        *prometheus.CounterVec
-}
-
-func NewSyncStats() *Stats {
-	CounterRuleEval := prometheus.NewCounterVec(prometheus.CounterOpts{
-		Namespace: namespace,
-		Subsystem: subsystem,
-		Name:      "rule_eval_total",
-		Help:      "Number of rule eval.",
-	}, []string{})
-
-	CounterRuleEvalErrorTotal := prometheus.NewCounterVec(prometheus.CounterOpts{
-		Namespace: namespace,
-		Subsystem: subsystem,
-		Name:      "rule_eval_error_total",
-		Help:      "Number of rule eval error.",
-	}, []string{"datasource", "stage"})
-
-	CounterQueryDataErrorTotal := prometheus.NewCounterVec(prometheus.CounterOpts{
-		Namespace: namespace,
-		Subsystem: subsystem,
-		Name:      "query_data_error_total",
-		Help:      "Number of rule eval query data error.",
-	}, []string{"datasource"})
-
-	CounterQueryDataTotal := prometheus.NewCounterVec(prometheus.CounterOpts{
-		Namespace: namespace,
-		Subsystem: subsystem,
-		Name:      "query_data_total",
-		Help:      "Number of rule eval query data.",
-	}, []string{"datasource"})
-
-	CounterRecordEval := prometheus.NewCounterVec(prometheus.CounterOpts{
-		Namespace: namespace,
-		Subsystem: subsystem,
-		Name:      "record_eval_total",
-		Help:      "Number of record eval.",
-	}, []string{"datasource"})
-
-	CounterRecordEvalErrorTotal := prometheus.NewCounterVec(prometheus.CounterOpts{
-		Namespace: namespace,
-		Subsystem: subsystem,
-		Name:      "record_eval_error_total",
-		Help:      "Number of record eval error.",
-	}, []string{"datasource"})
-
-	AlertNotifyTotal := prometheus.NewCounterVec(prometheus.CounterOpts{
-		Namespace: namespace,
-		Subsystem: subsystem,
-		Name:      "alert_notify_total",
-		Help:      "Number of send msg.",
-	}, []string{"channel"})
-
-	AlertNotifyErrorTotal := prometheus.NewCounterVec(prometheus.CounterOpts{
-		Namespace: namespace,
-		Subsystem: subsystem,
-		Name:      "alert_notify_error_total",
-		Help:      "Number of send msg.",
-	}, []string{"channel"})
-
-	// 产生的告警总量
-	CounterAlertsTotal := prometheus.NewCounterVec(prometheus.CounterOpts{
-		Namespace: namespace,
-		Subsystem: subsystem,
-		Name:      "alerts_total",
-		Help:      "Total number alert events.",
-	}, []string{"cluster", "type", "busi_group"})
-
-	// 内存中的告警事件队列的长度
-	GaugeAlertQueueSize := prometheus.NewGauge(prometheus.GaugeOpts{
-		Namespace: namespace,
-		Subsystem: subsystem,
-		Name:      "alert_queue_size",
-		Help:      "The size of alert queue.",
-	})
-
-	CounterMuteTotal := prometheus.NewCounterVec(prometheus.CounterOpts{
-		Namespace: namespace,
-		Subsystem: subsystem,
-		Name:      "mute_total",
-		Help:      "Number of mute.",
-	}, []string{"group"})
-
-	CounterSubEventTotal := prometheus.NewCounterVec(prometheus.CounterOpts{
-		Namespace: namespace,
-		Subsystem: subsystem,
-		Name:      "sub_event_total",
-		Help:      "Number of sub event.",
-	}, []string{"group"})
-
-	CounterHeartbeatErrorTotal := prometheus.NewCounterVec(prometheus.CounterOpts{
-		Namespace: namespace,
-		Subsystem: subsystem,
-		Name:      "heartbeat_error_count",
-		Help:      "Number of heartbeat error.",
-	}, []string{})
-
-	prometheus.MustRegister(
-		CounterAlertsTotal,
-		GaugeAlertQueueSize,
-		AlertNotifyTotal,
-		AlertNotifyErrorTotal,
-		CounterRuleEval,
-		CounterQueryDataTotal,
-		CounterQueryDataErrorTotal,
-		CounterRecordEval,
-		CounterRecordEvalErrorTotal,
-		CounterMuteTotal,
-		CounterRuleEvalErrorTotal,
-		CounterHeartbeatErrorTotal,
-		CounterSubEventTotal,
-	)
-
-	return &Stats{
-		CounterAlertsTotal:          CounterAlertsTotal,
-		GaugeAlertQueueSize:         GaugeAlertQueueSize,
-		AlertNotifyTotal:            AlertNotifyTotal,
-		AlertNotifyErrorTotal:       AlertNotifyErrorTotal,
-		CounterRuleEval:             CounterRuleEval,
-		CounterQueryDataTotal:       CounterQueryDataTotal,
-		CounterQueryDataErrorTotal:  CounterQueryDataErrorTotal,
-		CounterRecordEval:           CounterRecordEval,
-		CounterRecordEvalErrorTotal: CounterRecordEvalErrorTotal,
-		CounterMuteTotal:            CounterMuteTotal,
-		CounterRuleEvalErrorTotal:   CounterRuleEvalErrorTotal,
-		CounterHeartbeatErrorTotal:  CounterHeartbeatErrorTotal,
-		CounterSubEventTotal:        CounterSubEventTotal,
-	}
-}

alert/common/key.go

@@ -1,53 +0,0 @@
-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 MatchGroupsName(groupName string, groupFilter []models.TagFilter) bool {
-	for _, filter := range groupFilter {
-		if !matchTag(groupName, 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
-}

alert/dispatch/consume.go

@@ -1,191 +0,0 @@
-package dispatch
-
-import (
-	"encoding/json"
-	"fmt"
-	"strings"
-	"time"
-
-	"github.com/ccfos/nightingale/v6/alert/aconf"
-	"github.com/ccfos/nightingale/v6/alert/common"
-	"github.com/ccfos/nightingale/v6/alert/queue"
-	"github.com/ccfos/nightingale/v6/models"
-	"github.com/ccfos/nightingale/v6/pkg/ctx"
-	"github.com/ccfos/nightingale/v6/pkg/poster"
-	promsdk "github.com/ccfos/nightingale/v6/pkg/prom"
-	"github.com/ccfos/nightingale/v6/prom"
-
-	"github.com/toolkits/pkg/concurrent/semaphore"
-	"github.com/toolkits/pkg/logger"
-)
-
-type Consumer struct {
-	alerting aconf.Alerting
-	ctx      *ctx.Context
-
-	dispatch    *Dispatch
-	promClients *prom.PromClientMap
-}
-
-// 创建一个 Consumer 实例
-func NewConsumer(alerting aconf.Alerting, ctx *ctx.Context, dispatch *Dispatch, promClients *prom.PromClientMap) *Consumer {
-	return &Consumer{
-		alerting:    alerting,
-		ctx:         ctx,
-		dispatch:    dispatch,
-		promClients: promClients,
-	}
-}
-
-func (e *Consumer) LoopConsume() {
-	sema := semaphore.NewSemaphore(e.alerting.NotifyConcurrency)
-	duration := time.Duration(100) * time.Millisecond
-	for {
-		events := queue.EventQueue.PopBackBy(100)
-		if len(events) == 0 {
-			time.Sleep(duration)
-			continue
-		}
-		e.consume(events, sema)
-	}
-}
-
-func (e *Consumer) consume(events []interface{}, sema *semaphore.Semaphore) {
-	for i := range events {
-		if events[i] == nil {
-			continue
-		}
-
-		event := events[i].(*models.AlertCurEvent)
-		sema.Acquire()
-		go func(event *models.AlertCurEvent) {
-			defer sema.Release()
-			e.consumeOne(event)
-		}(event)
-	}
-}
-
-func (e *Consumer) consumeOne(event *models.AlertCurEvent) {
-	LogEvent(event, "consume")
-
-	eventType := "alert"
-	if event.IsRecovered {
-		eventType = "recovery"
-	}
-
-	e.dispatch.Astats.CounterAlertsTotal.WithLabelValues(event.Cluster, eventType, event.GroupName).Inc()
-
-	if err := event.ParseRule("rule_name"); err != nil {
-		logger.Warningf("ruleid:%d failed to parse rule name: %v", event.RuleId, err)
-		event.RuleName = fmt.Sprintf("failed to parse rule name: %v", err)
-	}
-
-	if err := event.ParseRule("annotations"); err != nil {
-		logger.Warningf("ruleid:%d failed to parse annotations: %v", event.RuleId, err)
-		event.Annotations = fmt.Sprintf("failed to parse annotations: %v", err)
-		event.AnnotationsJSON["error"] = event.Annotations
-	}
-
-	e.queryRecoveryVal(event)
-
-	if err := event.ParseRule("rule_note"); err != nil {
-		logger.Warningf("ruleid:%d failed to parse rule note: %v", event.RuleId, err)
-		event.RuleNote = fmt.Sprintf("failed to parse rule note: %v", err)
-	}
-
-	e.persist(event)
-
-	if event.IsRecovered && event.NotifyRecovered == 0 {
-		return
-	}
-
-	e.dispatch.HandleEventNotify(event, false)
-}
-
-func (e *Consumer) persist(event *models.AlertCurEvent) {
-	if event.Status != 0 {
-		return
-	}
-
-	if !e.ctx.IsCenter {
-		event.DB2FE()
-		var err error
-		event.Id, err = poster.PostByUrlsWithResp[int64](e.ctx, "/v1/n9e/event-persist", event)
-		if err != nil {
-			logger.Errorf("event:%+v persist err:%v", event, err)
-			e.dispatch.Astats.CounterRuleEvalErrorTotal.WithLabelValues(fmt.Sprintf("%v", event.DatasourceId), "persist_event").Inc()
-		}
-		return
-	}
-
-	err := models.EventPersist(e.ctx, event)
-	if err != nil {
-		logger.Errorf("event%+v persist err:%v", event, err)
-		e.dispatch.Astats.CounterRuleEvalErrorTotal.WithLabelValues(fmt.Sprintf("%v", event.DatasourceId), "persist_event").Inc()
-	}
-}
-
-func (e *Consumer) queryRecoveryVal(event *models.AlertCurEvent) {
-	if !event.IsRecovered {
-		return
-	}
-
-	// If the event is a recovery event, execute the recovery_promql query
-	promql, ok := event.AnnotationsJSON["recovery_promql"]
-	if !ok {
-		return
-	}
-
-	promql = strings.TrimSpace(promql)
-	if promql == "" {
-		logger.Warningf("rule_eval:%s promql is blank", getKey(event))
-		return
-	}
-
-	if e.promClients.IsNil(event.DatasourceId) {
-		logger.Warningf("rule_eval:%s error reader client is nil", getKey(event))
-		return
-	}
-
-	readerClient := e.promClients.GetCli(event.DatasourceId)
-
-	var warnings promsdk.Warnings
-	value, warnings, err := readerClient.Query(e.ctx.Ctx, promql, time.Now())
-	if err != nil {
-		logger.Errorf("rule_eval:%s promql:%s, error:%v", getKey(event), promql, err)
-		event.AnnotationsJSON["recovery_promql_error"] = fmt.Sprintf("promql:%s error:%v", promql, err)
-
-		b, err := json.Marshal(event.AnnotationsJSON)
-		if err != nil {
-			event.AnnotationsJSON = make(map[string]string)
-			event.AnnotationsJSON["error"] = fmt.Sprintf("failed to parse annotations: %v", err)
-		} else {
-			event.Annotations = string(b)
-		}
-		return
-	}
-
-	if len(warnings) > 0 {
-		logger.Errorf("rule_eval:%s promql:%s, warnings:%v", getKey(event), promql, warnings)
-	}
-
-	anomalyPoints := common.ConvertAnomalyPoints(value)
-	if len(anomalyPoints) == 0 {
-		logger.Warningf("rule_eval:%s promql:%s, result is empty", getKey(event), promql)
-		event.AnnotationsJSON["recovery_promql_error"] = fmt.Sprintf("promql:%s error:%s", promql, "result is empty")
-	} else {
-		event.AnnotationsJSON["recovery_value"] = fmt.Sprintf("%v", anomalyPoints[0].Value)
-	}
-
-	b, err := json.Marshal(event.AnnotationsJSON)
-	if err != nil {
-		event.AnnotationsJSON = make(map[string]string)
-		event.AnnotationsJSON["error"] = fmt.Sprintf("failed to parse annotations: %v", err)
-	} else {
-		event.Annotations = string(b)
-	}
-}
-
-func getKey(event *models.AlertCurEvent) string {
-	return common.RuleKey(event.DatasourceId, event.RuleId)
-}

alert/dispatch/dispatch.go

@@ -1,385 +0,0 @@
-package dispatch
-
-import (
-	"bytes"
-	"encoding/json"
-	"html/template"
-	"net/url"
-	"strconv"
-	"strings"
-	"sync"
-	"time"
-
-	"github.com/ccfos/nightingale/v6/alert/aconf"
-	"github.com/ccfos/nightingale/v6/alert/astats"
-	"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
-	notifyConfigCache   *memsto.NotifyConfigCacheType
-	taskTplsCache       *memsto.TaskTplCache
-
-	alerting aconf.Alerting
-
-	Senders          map[string]sender.Sender
-	CallBacks        map[string]sender.CallBacker
-	tpls             map[string]*template.Template
-	ExtraSenders     map[string]sender.Sender
-	BeforeSenderHook func(*models.AlertCurEvent) bool
-
-	ctx    *ctx.Context
-	Astats *astats.Stats
-
-	RwLock sync.RWMutex
-}
-
-// 创建一个 Notify 实例
-func NewDispatch(alertRuleCache *memsto.AlertRuleCacheType, userCache *memsto.UserCacheType, userGroupCache *memsto.UserGroupCacheType,
-	alertSubscribeCache *memsto.AlertSubscribeCacheType, targetCache *memsto.TargetCacheType, notifyConfigCache *memsto.NotifyConfigCacheType,
-	taskTplsCache *memsto.TaskTplCache, alerting aconf.Alerting, ctx *ctx.Context, astats *astats.Stats) *Dispatch {
-	notify := &Dispatch{
-		alertRuleCache:      alertRuleCache,
-		userCache:           userCache,
-		userGroupCache:      userGroupCache,
-		alertSubscribeCache: alertSubscribeCache,
-		targetCache:         targetCache,
-		notifyConfigCache:   notifyConfigCache,
-		taskTplsCache:       taskTplsCache,
-
-		alerting: alerting,
-
-		Senders:          make(map[string]sender.Sender),
-		tpls:             make(map[string]*template.Template),
-		ExtraSenders:     make(map[string]sender.Sender),
-		BeforeSenderHook: func(*models.AlertCurEvent) bool { return true },
-
-		ctx:    ctx,
-		Astats: astats,
-	}
-	return notify
-}
-
-func (e *Dispatch) ReloadTpls() error {
-	err := e.relaodTpls()
-	if err != nil {
-		logger.Errorf("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
-	}
-	smtp := e.notifyConfigCache.GetSMTP()
-
-	senders := map[string]sender.Sender{
-		models.Email:      sender.NewSender(models.Email, tmpTpls, smtp),
-		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),
-		models.FeishuCard: sender.NewSender(models.FeishuCard, tmpTpls),
-		models.Lark:       sender.NewSender(models.Lark, tmpTpls),
-		models.LarkCard:   sender.NewSender(models.LarkCard, tmpTpls),
-	}
-
-	// domain -> Callback()
-	callbacks := map[string]sender.CallBacker{
-		models.DingtalkDomain:   sender.NewCallBacker(models.DingtalkDomain, e.targetCache, e.userCache, e.taskTplsCache, tmpTpls),
-		models.WecomDomain:      sender.NewCallBacker(models.WecomDomain, e.targetCache, e.userCache, e.taskTplsCache, tmpTpls),
-		models.FeishuDomain:     sender.NewCallBacker(models.FeishuDomain, e.targetCache, e.userCache, e.taskTplsCache, tmpTpls),
-		models.TelegramDomain:   sender.NewCallBacker(models.TelegramDomain, e.targetCache, e.userCache, e.taskTplsCache, tmpTpls),
-		models.FeishuCardDomain: sender.NewCallBacker(models.FeishuCardDomain, e.targetCache, e.userCache, e.taskTplsCache, tmpTpls),
-		models.IbexDomain:       sender.NewCallBacker(models.IbexDomain, e.targetCache, e.userCache, e.taskTplsCache, tmpTpls),
-		models.LarkDomain:       sender.NewCallBacker(models.LarkDomain, e.targetCache, e.userCache, e.taskTplsCache, tmpTpls),
-		models.DefaultDomain:    sender.NewCallBacker(models.DefaultDomain, e.targetCache, e.userCache, e.taskTplsCache, tmpTpls),
-		models.LarkCardDomain:   sender.NewCallBacker(models.LarkCardDomain, e.targetCache, e.userCache, e.taskTplsCache, tmpTpls),
-	}
-
-	e.RwLock.RLock()
-	for channelName, extraSender := range e.ExtraSenders {
-		senders[channelName] = extraSender
-	}
-	e.RwLock.RUnlock()
-
-	e.RwLock.Lock()
-	e.tpls = tmpTpls
-	e.Senders = senders
-	e.CallBacks = callbacks
-	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)
-
-	// 如果是不是订阅规则出现的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() {
-		return
-	}
-
-	if !sub.MatchCluster(event.DatasourceId) {
-		return
-	}
-
-	if !sub.MatchProd(event.RuleProd) {
-		return
-	}
-
-	if !common.MatchTags(event.TagsMap, sub.ITags) {
-		return
-	}
-	// event BusiGroups filter
-	if !common.MatchGroupsName(event.GroupName, sub.IBusiGroups) {
-		return
-	}
-	if sub.ForDuration > (event.TriggerTime - event.FirstTriggerTime) {
-		return
-	}
-
-	if len(sub.SeveritiesJson) != 0 {
-		match := false
-		for _, s := range sub.SeveritiesJson {
-			if s == event.Severity || s == 0 {
-				match = true
-				break
-			}
-		}
-		if !match {
-			return
-		}
-	}
-
-	e.Astats.CounterSubEventTotal.WithLabelValues(event.GroupName).Inc()
-	sub.ModifyEvent(&event)
-	event.SubRuleId = sub.Id
-
-	LogEvent(&event, "subscribe")
-	e.HandleEventNotify(&event, true)
-}
-
-func (e *Dispatch) Send(rule *models.AlertRule, event *models.AlertCurEvent, notifyTarget *NotifyTarget) {
-	needSend := e.BeforeSenderHook(event)
-	if needSend {
-		for channel, uids := range notifyTarget.ToChannelUserMap() {
-			msgCtx := sender.BuildMessageContext(rule, []*models.AlertCurEvent{event}, uids, e.userCache, e.Astats)
-			e.RwLock.RLock()
-			s := e.Senders[channel]
-			e.RwLock.RUnlock()
-			if s == nil {
-				logger.Debugf("no sender for channel: %s", channel)
-				continue
-			}
-
-			var event *models.AlertCurEvent
-			if len(msgCtx.Events) > 0 {
-				event = msgCtx.Events[0]
-			}
-
-			logger.Debugf("send to channel:%s event:%+v users:%+v", channel, event, msgCtx.Users)
-			s.Send(msgCtx)
-		}
-	}
-
-	// handle event callbacks
-	e.SendCallbacks(rule, notifyTarget, event)
-
-	// handle global webhooks
-	if e.alerting.WebhookBatchSend {
-		sender.BatchSendWebhooks(notifyTarget.ToWebhookList(), event, e.Astats)
-	} else {
-		sender.SingleSendWebhooks(notifyTarget.ToWebhookList(), event, e.Astats)
-	}
-
-	// handle plugin call
-	go sender.MayPluginNotify(e.genNoticeBytes(event), e.notifyConfigCache.GetNotifyScript(), e.Astats)
-}
-
-func (e *Dispatch) SendCallbacks(rule *models.AlertRule, notifyTarget *NotifyTarget, event *models.AlertCurEvent) {
-
-	uids := notifyTarget.ToUidList()
-	urls := notifyTarget.ToCallbackList()
-	for _, urlStr := range urls {
-		if len(urlStr) == 0 {
-			continue
-		}
-
-		cbCtx := sender.BuildCallBackContext(e.ctx, urlStr, rule, []*models.AlertCurEvent{event}, uids, e.userCache, e.alerting.WebhookBatchSend, e.Astats)
-
-		if strings.HasPrefix(urlStr, "${ibex}") {
-			e.CallBacks[models.IbexDomain].CallBack(cbCtx)
-			continue
-		}
-
-		if !(strings.HasPrefix(urlStr, "http://") || strings.HasPrefix(urlStr, "https://")) {
-			cbCtx.CallBackURL = "http://" + urlStr
-		}
-
-		parsedURL, err := url.Parse(urlStr)
-		if err != nil {
-			logger.Errorf("SendCallbacks: failed to url.Parse(urlStr=%s): %v", urlStr, err)
-			continue
-		}
-
-		// process feishu card
-		if parsedURL.Host == models.FeishuDomain && parsedURL.Query().Get("card") == "1" {
-			e.CallBacks[models.FeishuCardDomain].CallBack(cbCtx)
-			continue
-		}
-
-		// process lark card
-		if parsedURL.Host == models.LarkDomain && parsedURL.Query().Get("card") == "1" {
-			e.CallBacks[models.LarkCardDomain].CallBack(cbCtx)
-			continue
-		}
-
-		callBacker, ok := e.CallBacks[parsedURL.Host]
-		if ok {
-			callBacker.CallBack(cbCtx)
-		} else {
-			e.CallBacks[models.DefaultDomain].CallBack(cbCtx)
-		}
-	}
-}
-
-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
-}

alert/dispatch/notify_channel.go

@@ -1,33 +0,0 @@
-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
-		}
-	}
-}

alert/dispatch/notify_target.go

@@ -1,158 +0,0 @@
-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 {
-		if wh.Batch == 0 {
-			wh.Batch = 1000
-		}
-
-		if wh.Timeout == 0 {
-			wh.Timeout = 10
-		}
-
-		if wh.RetryCount == 0 {
-			wh.RetryCount = 10
-		}
-
-		if wh.RetryInterval == 0 {
-			wh.RetryInterval = 10
-		}
-
-		webhooks = append(webhooks, wh)
-	}
-	return webhooks
-}
-
-func (s *NotifyTarget) ToUidList() []int64 {
-	uids := make([]int64, len(s.userMap))
-	for uid, _ := range s.userMap {
-		uids = append(uids, uid)
-	}
-	return uids
-}
-
-// 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.notifyConfigCache.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
-}

alert/eval/alert_rule.go

@@ -1,188 +0,0 @@
-package eval
-
-import (
-	"context"
-	"fmt"
-	"strconv"
-	"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"
-	"github.com/ccfos/nightingale/v6/tdengine"
-
-	"github.com/toolkits/pkg/logger"
-)
-
-type Scheduler struct {
-	// key: hash
-	alertRules map[string]*AlertRuleWorker
-
-	ExternalProcessors *process.ExternalProcessorsType
-
-	aconf aconf.Alert
-
-	alertRuleCache          *memsto.AlertRuleCacheType
-	targetCache             *memsto.TargetCacheType
-	targetsOfAlertRuleCache *memsto.TargetsOfAlertRuleCacheType
-	busiGroupCache          *memsto.BusiGroupCacheType
-	alertMuteCache          *memsto.AlertMuteCacheType
-	datasourceCache         *memsto.DatasourceCacheType
-
-	promClients     *prom.PromClientMap
-	tdengineClients *tdengine.TdengineClientMap
-
-	naming *naming.Naming
-
-	ctx   *ctx.Context
-	stats *astats.Stats
-}
-
-func NewScheduler(aconf aconf.Alert, externalProcessors *process.ExternalProcessorsType, arc *memsto.AlertRuleCacheType,
-	targetCache *memsto.TargetCacheType, toarc *memsto.TargetsOfAlertRuleCacheType,
-	busiGroupCache *memsto.BusiGroupCacheType, alertMuteCache *memsto.AlertMuteCacheType, datasourceCache *memsto.DatasourceCacheType,
-	promClients *prom.PromClientMap, tdengineClients *tdengine.TdengineClientMap, naming *naming.Naming, ctx *ctx.Context, stats *astats.Stats) *Scheduler {
-	scheduler := &Scheduler{
-		aconf:      aconf,
-		alertRules: make(map[string]*AlertRuleWorker),
-
-		ExternalProcessors: externalProcessors,
-
-		alertRuleCache:          arc,
-		targetCache:             targetCache,
-		targetsOfAlertRuleCache: toarc,
-		busiGroupCache:          busiGroupCache,
-		alertMuteCache:          alertMuteCache,
-		datasourceCache:         datasourceCache,
-
-		promClients:     promClients,
-		tdengineClients: tdengineClients,
-		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
-		}
-
-		ruleType := rule.GetRuleType()
-		if rule.IsPrometheusRule() || rule.IsLokiRule() || rule.IsTdengineRule() {
-			datasourceIds := s.promClients.Hit(rule.DatasourceIdsJson)
-			datasourceIds = append(datasourceIds, s.tdengineClients.Hit(rule.DatasourceIdsJson)...)
-			for _, dsId := range datasourceIds {
-				if !naming.DatasourceHashRing.IsHit(strconv.FormatInt(dsId, 10), fmt.Sprintf("%d", rule.Id), s.aconf.Heartbeat.Endpoint) {
-					continue
-				}
-				ds := s.datasourceCache.GetById(dsId)
-				if ds == nil {
-					logger.Debugf("datasource %d not found", dsId)
-					continue
-				}
-
-				if ds.PluginType != ruleType {
-					logger.Debugf("datasource %d category is %s not %s", dsId, ds.PluginType, ruleType)
-					continue
-				}
-
-				if ds.Status != "enabled" {
-					logger.Debugf("datasource %d status is %s", dsId, ds.Status)
-					continue
-				}
-				processor := process.NewProcessor(s.aconf.Heartbeat.EngineName, rule, dsId, s.alertRuleCache, s.targetCache, s.targetsOfAlertRuleCache, s.busiGroupCache, s.alertMuteCache, s.datasourceCache, s.ctx, s.stats)
-
-				alertRule := NewAlertRuleWorker(rule, dsId, processor, s.promClients, s.tdengineClients, s.ctx)
-				alertRuleWorkers[alertRule.Hash()] = alertRule
-			}
-		} else if rule.IsHostRule() {
-			// all host rule will be processed by center instance
-			if !naming.DatasourceHashRing.IsHit(s.aconf.Heartbeat.EngineName, strconv.FormatInt(rule.Id, 10), s.aconf.Heartbeat.Endpoint) {
-				continue
-			}
-			processor := process.NewProcessor(s.aconf.Heartbeat.EngineName, rule, 0, s.alertRuleCache, s.targetCache, s.targetsOfAlertRuleCache, s.busiGroupCache, s.alertMuteCache, s.datasourceCache, s.ctx, s.stats)
-			alertRule := NewAlertRuleWorker(rule, 0, processor, s.promClients, s.tdengineClients, 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 {
-				ds := s.datasourceCache.GetById(dsId)
-				if ds == nil {
-					logger.Debugf("datasource %d not found", dsId)
-					continue
-				}
-
-				if ds.Status != "enabled" {
-					logger.Debugf("datasource %d status is %s", dsId, ds.Status)
-					continue
-				}
-				processor := process.NewProcessor(s.aconf.Heartbeat.EngineName, rule, dsId, s.alertRuleCache, s.targetCache, s.targetsOfAlertRuleCache, s.busiGroupCache, s.alertMuteCache, s.datasourceCache, 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()
-}

alert/eval/eval.go

@@ -1,534 +0,0 @@
-package eval
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-	"math"
-	"sort"
-	"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"
-	"github.com/ccfos/nightingale/v6/pkg/hash"
-	"github.com/ccfos/nightingale/v6/pkg/parser"
-	promsdk "github.com/ccfos/nightingale/v6/pkg/prom"
-	"github.com/ccfos/nightingale/v6/prom"
-	"github.com/ccfos/nightingale/v6/tdengine"
-
-	"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
-	tdengineClients *tdengine.TdengineClientMap
-	ctx             *ctx.Context
-}
-
-const (
-	GET_RULE_CONFIG = "get_rule_config"
-	GET_PROCESSOR   = "get_processor"
-	CHECK_QUERY     = "check_query_config"
-	GET_CLIENT      = "get_client"
-	QUERY_DATA      = "query_data"
-)
-
-func NewAlertRuleWorker(rule *models.AlertRule, datasourceId int64, processor *process.Processor, promClients *prom.PromClientMap, tdengineClients *tdengine.TdengineClientMap, ctx *ctx.Context) *AlertRuleWorker {
-	arw := &AlertRuleWorker{
-		datasourceId: datasourceId,
-		quit:         make(chan struct{}),
-		rule:         rule,
-		processor:    processor,
-
-		promClients:     promClients,
-		tdengineClients: tdengineClients,
-		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
-	}
-
-	ticker := time.NewTicker(time.Duration(interval) * time.Second)
-	go func() {
-		defer ticker.Stop()
-		for {
-			select {
-			case <-arw.quit:
-				return
-			case <-ticker.C:
-				arw.Eval()
-			}
-		}
-	}()
-}
-
-func (arw *AlertRuleWorker) Eval() {
-	cachedRule := arw.rule
-	if cachedRule == nil {
-		// logger.Errorf("rule_eval:%s rule not found", arw.Key())
-		return
-	}
-	arw.processor.Stats.CounterRuleEval.WithLabelValues().Inc()
-
-	typ := cachedRule.GetRuleType()
-	var anomalyPoints []common.AnomalyPoint
-	var recoverPoints []common.AnomalyPoint
-	switch typ {
-	case models.PROMETHEUS:
-		anomalyPoints = arw.GetPromAnomalyPoint(cachedRule.RuleConfig)
-	case models.HOST:
-		anomalyPoints = arw.GetHostAnomalyPoint(cachedRule.RuleConfig)
-	case models.TDENGINE:
-		anomalyPoints, recoverPoints = arw.GetTdengineAnomalyPoint(cachedRule, arw.processor.DatasourceId())
-	case models.LOKI:
-		anomalyPoints = arw.GetPromAnomalyPoint(cachedRule.RuleConfig)
-	default:
-		return
-	}
-
-	if arw.processor == nil {
-		logger.Warningf("rule_eval:%s processor is nil", arw.Key())
-		return
-	}
-
-	if arw.inhibit {
-		pointsMap := make(map[string]common.AnomalyPoint)
-		for _, point := range recoverPoints {
-			// 对于恢复的事件，合并处理
-			tagHash := process.TagHash(point)
-
-			p, exists := pointsMap[tagHash]
-			if !exists {
-				pointsMap[tagHash] = point
-				continue
-			}
-
-			if p.Severity > point.Severity {
-				hash := process.Hash(cachedRule.Id, arw.processor.DatasourceId(), p)
-				arw.processor.DeleteProcessEvent(hash)
-				models.AlertCurEventDelByHash(arw.ctx, hash)
-
-				pointsMap[tagHash] = point
-			}
-		}
-
-		now := time.Now().Unix()
-		for _, point := range pointsMap {
-			str := fmt.Sprintf("%v", point.Value)
-			arw.processor.RecoverSingle(process.Hash(cachedRule.Id, arw.processor.DatasourceId(), point), now, &str)
-		}
-	} else {
-		now := time.Now().Unix()
-		for _, point := range recoverPoints {
-			str := fmt.Sprintf("%v", point.Value)
-			arw.processor.RecoverSingle(process.Hash(cachedRule.Id, arw.processor.DatasourceId(), point), now, &str)
-		}
-	}
-
-	arw.processor.Handle(anomalyPoints, "inner", arw.inhibit)
-}
-
-func (arw *AlertRuleWorker) Stop() {
-	logger.Infof("rule_eval %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)
-		arw.processor.Stats.CounterRuleEvalErrorTotal.WithLabelValues(fmt.Sprintf("%v", arw.processor.DatasourceId()), GET_RULE_CONFIG).Inc()
-		return lst
-	}
-
-	if rule == nil {
-		logger.Errorf("rule_eval:%s rule_config:%s, error:rule is nil", arw.Key(), ruleConfig)
-		arw.processor.Stats.CounterRuleEvalErrorTotal.WithLabelValues(fmt.Sprintf("%v", arw.processor.DatasourceId()), GET_RULE_CONFIG).Inc()
-		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.Warningf("rule_eval:%s promql is blank", arw.Key())
-			arw.processor.Stats.CounterRuleEvalErrorTotal.WithLabelValues(fmt.Sprintf("%v", arw.processor.DatasourceId()), CHECK_QUERY).Inc()
-			continue
-		}
-
-		if arw.promClients.IsNil(arw.datasourceId) {
-			logger.Warningf("rule_eval:%s error reader client is nil", arw.Key())
-			arw.processor.Stats.CounterRuleEvalErrorTotal.WithLabelValues(fmt.Sprintf("%v", arw.processor.DatasourceId()), GET_CLIENT).Inc()
-			continue
-		}
-
-		readerClient := arw.promClients.GetCli(arw.datasourceId)
-
-		var warnings promsdk.Warnings
-		arw.processor.Stats.CounterQueryDataTotal.WithLabelValues(fmt.Sprintf("%d", arw.datasourceId)).Inc()
-		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)
-			arw.processor.Stats.CounterQueryDataErrorTotal.WithLabelValues(fmt.Sprintf("%d", arw.datasourceId)).Inc()
-			arw.processor.Stats.CounterRuleEvalErrorTotal.WithLabelValues(fmt.Sprintf("%v", arw.processor.DatasourceId()), QUERY_DATA).Inc()
-			continue
-		}
-
-		if len(warnings) > 0 {
-			logger.Errorf("rule_eval:%s promql:%s, warnings:%v", arw.Key(), promql, warnings)
-			arw.processor.Stats.CounterQueryDataErrorTotal.WithLabelValues(fmt.Sprintf("%d", arw.datasourceId)).Inc()
-			arw.processor.Stats.CounterRuleEvalErrorTotal.WithLabelValues(fmt.Sprintf("%v", arw.processor.DatasourceId()), QUERY_DATA).Inc()
-		}
-
-		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
-			points[i].Query = promql
-		}
-		lst = append(lst, points...)
-	}
-	return lst
-}
-
-func (arw *AlertRuleWorker) GetTdengineAnomalyPoint(rule *models.AlertRule, dsId int64) ([]common.AnomalyPoint, []common.AnomalyPoint) {
-	// 获取查询和规则判断条件
-	points := []common.AnomalyPoint{}
-	recoverPoints := []common.AnomalyPoint{}
-	ruleConfig := strings.TrimSpace(rule.RuleConfig)
-	if ruleConfig == "" {
-		logger.Warningf("rule_eval:%d promql is blank", rule.Id)
-		arw.processor.Stats.CounterRuleEvalErrorTotal.WithLabelValues(fmt.Sprintf("%v", arw.processor.DatasourceId()), GET_RULE_CONFIG).Inc()
-		return points, recoverPoints
-	}
-
-	var ruleQuery models.RuleQuery
-	err := json.Unmarshal([]byte(ruleConfig), &ruleQuery)
-	if err != nil {
-		logger.Warningf("rule_eval:%d promql parse error:%s", rule.Id, err.Error())
-		arw.processor.Stats.CounterRuleEvalErrorTotal.WithLabelValues(fmt.Sprintf("%v", arw.processor.DatasourceId())).Inc()
-		arw.processor.Stats.CounterRuleEvalErrorTotal.WithLabelValues(fmt.Sprintf("%v", arw.processor.DatasourceId()), GET_RULE_CONFIG).Inc()
-		return points, recoverPoints
-	}
-
-	arw.inhibit = ruleQuery.Inhibit
-	if len(ruleQuery.Queries) > 0 {
-		seriesStore := make(map[uint64]models.DataResp)
-		seriesTagIndex := make(map[uint64][]uint64)
-
-		for _, query := range ruleQuery.Queries {
-			arw.processor.Stats.CounterQueryDataTotal.WithLabelValues(fmt.Sprintf("%d", arw.datasourceId)).Inc()
-			cli := arw.tdengineClients.GetCli(dsId)
-			if cli == nil {
-				logger.Warningf("rule_eval:%d tdengine client is nil", rule.Id)
-				arw.processor.Stats.CounterQueryDataErrorTotal.WithLabelValues(fmt.Sprintf("%d", arw.datasourceId)).Inc()
-				arw.processor.Stats.CounterRuleEvalErrorTotal.WithLabelValues(fmt.Sprintf("%v", arw.processor.DatasourceId()), GET_CLIENT).Inc()
-				continue
-			}
-
-			series, err := cli.Query(query)
-			arw.processor.Stats.CounterQueryDataTotal.WithLabelValues(fmt.Sprintf("%d", arw.datasourceId)).Inc()
-			if err != nil {
-				logger.Warningf("rule_eval rid:%d query data error: %v", rule.Id, err)
-				arw.processor.Stats.CounterQueryDataErrorTotal.WithLabelValues(fmt.Sprintf("%d", arw.datasourceId)).Inc()
-				arw.processor.Stats.CounterRuleEvalErrorTotal.WithLabelValues(fmt.Sprintf("%v", arw.processor.DatasourceId()), QUERY_DATA).Inc()
-				continue
-			}
-
-			//  此条日志很重要，是告警判断的现场值
-			logger.Debugf("rule_eval rid:%d req:%+v resp:%+v", rule.Id, query, series)
-			MakeSeriesMap(series, seriesTagIndex, seriesStore)
-		}
-
-		points, recoverPoints = GetAnomalyPoint(rule.Id, ruleQuery, seriesTagIndex, seriesStore)
-	}
-
-	return points, recoverPoints
-}
-
-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)
-		arw.processor.Stats.CounterRuleEvalErrorTotal.WithLabelValues(fmt.Sprintf("%v", arw.processor.DatasourceId()), GET_RULE_CONFIG).Inc()
-		return lst
-	}
-
-	if rule == nil {
-		logger.Errorf("rule_eval:%s rule_config:%s, error:rule is nil", arw.Key(), ruleConfig)
-		arw.processor.Stats.CounterRuleEvalErrorTotal.WithLabelValues(fmt.Sprintf("%v", arw.processor.DatasourceId()), GET_RULE_CONFIG).Inc()
-		return lst
-	}
-
-	arw.inhibit = rule.Inhibit
-	now := time.Now().Unix()
-	for _, trigger := range rule.Triggers {
-		if trigger.Severity < severity {
-			arw.severity = trigger.Severity
-		}
-
-		switch trigger.Type {
-		case "target_miss":
-			t := now - int64(trigger.Duration)
-
-			var idents, engineIdents, missEngineIdents []string
-			var exists bool
-			if arw.ctx.IsCenter {
-				// 如果是中心节点, 将不再上报数据的主机 engineName 为空的机器，也加入到 targets 中
-				missEngineIdents, exists = arw.processor.TargetsOfAlertRuleCache.Get("", arw.rule.Id)
-				if !exists {
-					logger.Debugf("rule_eval:%s targets not found engineName:%s", arw.Key(), arw.processor.EngineName)
-					arw.processor.Stats.CounterRuleEvalErrorTotal.WithLabelValues(fmt.Sprintf("%v", arw.processor.DatasourceId()), QUERY_DATA).Inc()
-				}
-			}
-			idents = append(idents, missEngineIdents...)
-
-			engineIdents, exists = arw.processor.TargetsOfAlertRuleCache.Get(arw.processor.EngineName, arw.rule.Id)
-			if !exists {
-				logger.Warningf("rule_eval:%s targets not found engineName:%s", arw.Key(), arw.processor.EngineName)
-				arw.processor.Stats.CounterRuleEvalErrorTotal.WithLabelValues(fmt.Sprintf("%v", arw.processor.DatasourceId()), QUERY_DATA).Inc()
-			}
-			idents = append(idents, engineIdents...)
-
-			if len(idents) == 0 {
-				continue
-			}
-
-			var missTargets []string
-			targetUpdateTimeMap := arw.processor.TargetCache.GetHostUpdateTime(idents)
-			for ident, updateTime := range targetUpdateTimeMap {
-				if updateTime < t {
-					missTargets = append(missTargets, ident)
-				}
-			}
-			logger.Debugf("rule_eval:%s missTargets:%v", arw.Key(), missTargets)
-			targets := arw.processor.TargetCache.Gets(missTargets)
-			for _, target := range targets {
-				m := make(map[string]string)
-				target.FillTagsMap()
-				for k, v := range target.TagsMap {
-					m[k] = v
-				}
-				m["ident"] = target.Ident
-
-				bg := arw.processor.BusiGroupCache.GetByBusiGroupId(target.GroupId)
-				if bg != nil && bg.LabelEnable == 1 {
-					m["busigroup"] = bg.LabelValue
-				}
-
-				lst = append(lst, common.NewAnomalyPoint(trigger.Type, m, now, float64(now-target.UpdateAt), trigger.Severity))
-			}
-		case "offset":
-			idents, exists := arw.processor.TargetsOfAlertRuleCache.Get(arw.processor.EngineName, arw.rule.Id)
-			if !exists {
-				logger.Warningf("rule_eval:%s targets not found", arw.Key())
-				arw.processor.Stats.CounterRuleEvalErrorTotal.WithLabelValues(fmt.Sprintf("%v", arw.processor.DatasourceId()), QUERY_DATA).Inc()
-				continue
-			}
-
-			targets := arw.processor.TargetCache.Gets(idents)
-			targetMap := make(map[string]*models.Target)
-			for _, target := range targets {
-				targetMap[target.Ident] = target
-			}
-
-			offsetIdents := make(map[string]int64)
-			targetsMeta := arw.processor.TargetCache.GetHostMetas(targets)
-			for ident, meta := range targetsMeta {
-				if meta.CpuNum <= 0 {
-					// means this target is not collect by categraf, do not check offset
-					continue
-				}
-				if target, exists := targetMap[ident]; exists {
-					if now-target.UpdateAt > 120 {
-						// means this target is not a active host, do not check offset
-						continue
-					}
-				}
-
-				offset := meta.Offset
-				if math.Abs(float64(offset)) > float64(trigger.Duration) {
-					offsetIdents[ident] = offset
-				}
-			}
-
-			logger.Debugf("rule_eval:%s offsetIdents:%v", arw.Key(), offsetIdents)
-			for host, offset := range offsetIdents {
-				m := make(map[string]string)
-				target, exists := arw.processor.TargetCache.Get(host)
-				if exists {
-					target.FillTagsMap()
-					for k, v := range target.TagsMap {
-						m[k] = v
-					}
-				}
-				m["ident"] = host
-
-				bg := arw.processor.BusiGroupCache.GetByBusiGroupId(target.GroupId)
-				if bg != nil && bg.LabelEnable == 1 {
-					m["busigroup"] = bg.LabelValue
-				}
-
-				lst = append(lst, common.NewAnomalyPoint(trigger.Type, m, now, float64(offset), trigger.Severity))
-			}
-		case "pct_target_miss":
-			t := now - int64(trigger.Duration)
-			idents, exists := arw.processor.TargetsOfAlertRuleCache.Get(arw.processor.EngineName, arw.rule.Id)
-			if !exists {
-				logger.Warningf("rule_eval:%s targets not found", arw.Key())
-				arw.processor.Stats.CounterRuleEvalErrorTotal.WithLabelValues(fmt.Sprintf("%v", arw.processor.DatasourceId()), QUERY_DATA).Inc()
-				continue
-			}
-
-			var missTargets []string
-			targetUpdateTimeMap := arw.processor.TargetCache.GetHostUpdateTime(idents)
-			for ident, updateTime := range targetUpdateTimeMap {
-				if updateTime < t {
-					missTargets = append(missTargets, ident)
-				}
-			}
-			logger.Debugf("rule_eval:%s missTargets:%v", arw.Key(), missTargets)
-			pct := float64(len(missTargets)) / float64(len(idents)) * 100
-			if pct >= float64(trigger.Percent) {
-				lst = append(lst, common.NewAnomalyPoint(trigger.Type, nil, now, pct, trigger.Severity))
-			}
-		}
-	}
-	return lst
-}
-
-func GetAnomalyPoint(ruleId int64, ruleQuery models.RuleQuery, seriesTagIndex map[uint64][]uint64, seriesStore map[uint64]models.DataResp) ([]common.AnomalyPoint, []common.AnomalyPoint) {
-	points := []common.AnomalyPoint{}
-	recoverPoints := []common.AnomalyPoint{}
-
-	for _, trigger := range ruleQuery.Triggers {
-		for _, seriesHash := range seriesTagIndex {
-			sort.Slice(seriesHash, func(i, j int) bool {
-				return seriesHash[i] < seriesHash[j]
-			})
-
-			m := make(map[string]float64)
-			var ts int64
-			var sample models.DataResp
-			var value float64
-			for _, serieHash := range seriesHash {
-				series, exists := seriesStore[serieHash]
-				if !exists {
-					logger.Warningf("rule_eval rid:%d series:%+v not found", ruleId, series)
-					continue
-				}
-				t, v, exists := series.Last()
-				if !exists {
-					logger.Warningf("rule_eval rid:%d series:%+v value not found", ruleId, series)
-					continue
-				}
-
-				if !strings.Contains(trigger.Exp, "$"+series.Ref) {
-					// 表达式中不包含该变量
-					continue
-				}
-
-				m["$"+series.Ref] = v
-				m["$"+series.Ref+"."+series.MetricName()] = v
-				ts = int64(t)
-				sample = series
-				value = v
-			}
-			isTriggered := parser.Calc(trigger.Exp, m)
-			//  此条日志很重要，是告警判断的现场值
-			logger.Infof("rule_eval rid:%d trigger:%+v exp:%s res:%v m:%v", ruleId, trigger, trigger.Exp, isTriggered, m)
-
-			var values string
-			for k, v := range m {
-				if !strings.Contains(k, ".") {
-					continue
-				}
-				values += fmt.Sprintf("%s:%v ", k, v)
-			}
-
-			point := common.AnomalyPoint{
-				Key:       sample.MetricName(),
-				Labels:    sample.Metric,
-				Timestamp: int64(ts),
-				Value:     value,
-				Values:    values,
-				Severity:  trigger.Severity,
-				Triggered: isTriggered,
-				Query:     fmt.Sprintf("query:%+v trigger:%+v", ruleQuery.Queries, trigger),
-			}
-
-			if sample.Query != "" {
-				point.Query = sample.Query
-			}
-
-			if isTriggered {
-				points = append(points, point)
-			} else {
-				recoverPoints = append(recoverPoints, point)
-			}
-		}
-	}
-
-	return points, recoverPoints
-}
-
-func MakeSeriesMap(series []models.DataResp, seriesTagIndex map[uint64][]uint64, seriesStore map[uint64]models.DataResp) {
-	for i := 0; i < len(series); i++ {
-		serieHash := hash.GetHash(series[i].Metric, series[i].Ref)
-		tagHash := hash.GetTagHash(series[i].Metric)
-		seriesStore[serieHash] = series[i]
-
-		// 将曲线按照相同的 tag 分组
-		if _, exists := seriesTagIndex[tagHash]; !exists {
-			seriesTagIndex[tagHash] = make([]uint64, 0)
-		}
-		seriesTagIndex[tagHash] = append(seriesTagIndex[tagHash], serieHash)
-	}
-}

alert/mute/mute.go

@@ -1,217 +0,0 @@
-package mute
-
-import (
-	"strconv"
-	"strings"
-	"time"
-
-	"github.com/ccfos/nightingale/v6/alert/common"
-	"github.com/ccfos/nightingale/v6/memsto"
-	"github.com/ccfos/nightingale/v6/models"
-
-	"github.com/toolkits/pkg/logger"
-)
-
-func IsMuted(rule *models.AlertRule, event *models.AlertCurEvent, targetCache *memsto.TargetCacheType, alertMuteCache *memsto.AlertMuteCacheType) (bool, string) {
-	if rule.Disabled == 1 {
-		return true, "rule disabled"
-	}
-
-	if TimeSpanMuteStrategy(rule, event) {
-		return true, "rule is not effective for period of time"
-	}
-
-	if IdentNotExistsMuteStrategy(rule, event, targetCache) {
-		return true, "ident not exists mute"
-	}
-
-	if BgNotMatchMuteStrategy(rule, event, targetCache) {
-		return true, "bg not match mute"
-	}
-
-	if EventMuteStrategy(event, alertMuteCache) {
-		return true, "match mute rule"
-	}
-
-	return false, ""
-}
-
-// TimeSpanMuteStrategy 根据规则配置的告警生效时间段过滤,如果产生的告警不在规则配置的告警生效时间段内,则不告警,即被mute
-// 时间范围，左闭右开，默认范围：00:00-24:00
-func TimeSpanMuteStrategy(rule *models.AlertRule, event *models.AlertCurEvent) bool {
-	tm := time.Unix(event.TriggerTime, 0)
-	triggerTime := tm.Format("15:04")
-	triggerWeek := strconv.Itoa(int(tm.Weekday()))
-
-	enableStime := strings.Fields(rule.EnableStime)
-	enableEtime := strings.Fields(rule.EnableEtime)
-	enableDaysOfWeek := strings.Split(rule.EnableDaysOfWeek, ";")
-	length := len(enableDaysOfWeek)
-	// enableStime,enableEtime,enableDaysOfWeek三者长度肯定相同，这里循环一个即可
-	for i := 0; i < length; i++ {
-		enableDaysOfWeek[i] = strings.Replace(enableDaysOfWeek[i], "7", "0", 1)
-		if !strings.Contains(enableDaysOfWeek[i], triggerWeek) {
-			continue
-		}
-
-		if enableStime[i] < enableEtime[i] {
-			if enableEtime[i] == "23:59" {
-				// 02:00-23:59，这种情况做个特殊处理，相当于左闭右闭区间了
-				if triggerTime < enableStime[i] {
-					// mute, 即没生效
-					continue
-				}
-			} else {
-				// 02:00-04:00 或者 02:00-24:00
-				if triggerTime < enableStime[i] || triggerTime >= enableEtime[i] {
-					// mute, 即没生效
-					continue
-				}
-			}
-		} else if enableStime[i] > enableEtime[i] {
-			// 21:00-09:00
-			if triggerTime < enableStime[i] && triggerTime >= enableEtime[i] {
-				// mute, 即没生效
-				continue
-			}
-		}
-
-		// 到这里说明当前时刻在告警规则的某组生效时间范围内，即没有 mute，直接返回 false
-		return false
-	}
-
-	return true
-}
-
-// IdentNotExistsMuteStrategy 根据ident是否存在过滤,如果ident不存在,则target_up的告警直接过滤掉
-func IdentNotExistsMuteStrategy(rule *models.AlertRule, event *models.AlertCurEvent, targetCache *memsto.TargetCacheType) bool {
-	ident, has := event.TagsMap["ident"]
-	if !has {
-		return false
-	}
-	_, exists := targetCache.Get(ident)
-	// 如果是target_up的告警,且ident已经不存在了,直接过滤掉
-	// 这里的判断有点太粗暴了,但是目前没有更好的办法
-	if !exists && strings.Contains(rule.PromQl, "target_up") {
-		logger.Debugf("[%s] mute: rule_eval:%d cluster:%s ident:%s", "IdentNotExistsMuteStrategy", rule.Id, event.Cluster, ident)
-		return true
-	}
-	return false
-}
-
-// BgNotMatchMuteStrategy 当规则开启只在bg内部告警时,对于非bg内部的机器过滤
-func BgNotMatchMuteStrategy(rule *models.AlertRule, event *models.AlertCurEvent, targetCache *memsto.TargetCacheType) bool {
-	// 没有开启BG内部告警,直接不过滤
-	if rule.EnableInBG == 0 {
-		return false
-	}
-
-	ident, has := event.TagsMap["ident"]
-	if !has {
-		return false
-	}
-
-	target, exists := targetCache.Get(ident)
-	// 对于包含ident的告警事件，check一下ident所属bg和rule所属bg是否相同
-	// 如果告警规则选择了只在本BG生效，那其他BG的机器就不能因此规则产生告警
-	if exists && target.GroupId != rule.GroupId {
-		logger.Debugf("[%s] mute: rule_eval:%d cluster:%s", "BgNotMatchMuteStrategy", rule.Id, event.Cluster)
-		return true
-	}
-	return false
-}
-
-func EventMuteStrategy(event *models.AlertCurEvent, alertMuteCache *memsto.AlertMuteCacheType) bool {
-	mutes, has := alertMuteCache.Gets(event.GroupId)
-	if !has || len(mutes) == 0 {
-		return false
-	}
-
-	for i := 0; i < len(mutes); i++ {
-		if matchMute(event, mutes[i]) {
-			return true
-		}
-	}
-
-	return false
-}
-
-// matchMute 如果传入了clock这个可选参数，就表示使用这个clock表示的时间，否则就从event的字段中取TriggerTime
-func matchMute(event *models.AlertCurEvent, mute *models.AlertMute, clock ...int64) bool {
-	if mute.Disabled == 1 {
-		return false
-	}
-	ts := event.TriggerTime
-	if len(clock) > 0 {
-		ts = clock[0]
-	}
-
-	// 如果不是全局的，判断 匹配的 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.datasourceId 是否包含在 idm 中
-		if _, has := idm[event.DatasourceId]; !has {
-			return false
-		}
-	}
-
-	var matchTime bool
-	if mute.MuteTimeType == models.TimeRange {
-		if ts < mute.Btime || ts > mute.Etime {
-			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 || (mute.PeriodicMutesJson[i].EnableStime == "00:00" && mute.PeriodicMutesJson[i].EnableEtime == "23:59") {
-					matchTime = true
-					break
-				} else 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
-					}
-				}
-			}
-		}
-	}
-	if !matchTime {
-		return false
-	}
-
-	var matchSeverity bool
-	if len(mute.SeveritiesJson) > 0 {
-		for _, s := range mute.SeveritiesJson {
-			if event.Severity == s || s == 0 {
-				matchSeverity = true
-				break
-			}
-		}
-	} else {
-		matchSeverity = true
-	}
-
-	if !matchSeverity {
-		return false
-	}
-
-	if mute.ITags == nil || len(mute.ITags) == 0 {
-		return true
-	}
-
-	return common.MatchTags(event.TagsMap, mute.ITags)
-}

alert/naming/hashring.go

@@ -1,85 +0,0 @@
-package naming
-
-import (
-	"errors"
-	"sync"
-
-	"github.com/toolkits/pkg/consistent"
-	"github.com/toolkits/pkg/logger"
-)
-
-const NodeReplicas = 500
-
-type DatasourceHashRingType struct {
-	sync.RWMutex
-	Rings map[string]*consistent.Consistent
-}
-
-// for alert_rule sharding
-var HostDatasource int64 = 99999999
-var DatasourceHashRing = DatasourceHashRingType{Rings: make(map[string]*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 string, 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 %s rebuild %+v", datasourceId, r.Members())
-}
-
-func (chr *DatasourceHashRingType) GetNode(datasourceId string, pk string) (string, error) {
-	chr.Lock()
-	defer chr.Unlock()
-	_, exists := chr.Rings[datasourceId]
-	if !exists {
-		chr.Rings[datasourceId] = NewConsistentHashRing(int32(NodeReplicas), []string{})
-	}
-
-	return chr.Rings[datasourceId].Get(pk)
-}
-
-func (chr *DatasourceHashRingType) IsHit(datasourceId string, pk string, currentNode string) bool {
-	node, err := chr.GetNode(datasourceId, pk)
-	if err != nil {
-		if !errors.Is(err, consistent.ErrEmptyCircle) {
-			logger.Errorf("rule id:%s is not work, datasource id:%s failed to get node from hashring:%v", pk, datasourceId, err)
-		}
-		return false
-	}
-	return node == currentNode
-}
-
-func (chr *DatasourceHashRingType) Set(datasourceId string, r *consistent.Consistent) {
-	chr.Lock()
-	defer chr.Unlock()
-	chr.Rings[datasourceId] = r
-}
-
-func (chr *DatasourceHashRingType) Del(datasourceId string) {
-	chr.Lock()
-	defer chr.Unlock()
-	delete(chr.Rings, datasourceId)
-}
-
-func (chr *DatasourceHashRingType) Clear(engineName string) {
-	chr.Lock()
-	defer chr.Unlock()
-	for id := range chr.Rings {
-		if id == engineName {
-			continue
-		}
-		delete(chr.Rings, id)
-	}
-}

alert/naming/heartbeat.go

@@ -1,192 +0,0 @@
-package naming
-
-import (
-	"fmt"
-	"sort"
-	"strings"
-	"time"
-
-	"github.com/ccfos/nightingale/v6/alert/aconf"
-	"github.com/ccfos/nightingale/v6/alert/astats"
-	"github.com/ccfos/nightingale/v6/models"
-	"github.com/ccfos/nightingale/v6/pkg/ctx"
-	"github.com/ccfos/nightingale/v6/pkg/poster"
-
-	"github.com/toolkits/pkg/logger"
-)
-
-type Naming struct {
-	ctx             *ctx.Context
-	heartbeatConfig aconf.HeartbeatConfig
-	astats          *astats.Stats
-}
-
-func NewNaming(ctx *ctx.Context, heartbeat aconf.HeartbeatConfig, alertStats *astats.Stats) *Naming {
-	naming := &Naming{
-		ctx:             ctx,
-		heartbeatConfig: heartbeat,
-		astats:          alertStats,
-	}
-	naming.Heartbeats()
-	return naming
-}
-
-// local servers
-var localss map[int64]string
-var localHostServers map[string]string
-
-func (n *Naming) Heartbeats() error {
-	localss = make(map[int64]string)
-	localHostServers = make(map[string]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() {
-	if !n.ctx.IsCenter {
-		return
-	}
-
-	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.heartbeatConfig.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.GetDatasourceIdsByEngineName(n.ctx, n.heartbeatConfig.EngineName)
-	if err != nil {
-		return err
-	}
-
-	if len(datasourceIds) == 0 {
-		err := models.AlertingEngineHeartbeatWithCluster(n.ctx, n.heartbeatConfig.Endpoint, n.heartbeatConfig.EngineName, 0)
-		if err != nil {
-			logger.Warningf("heartbeat with cluster %s err:%v", "", err)
-			n.astats.CounterHeartbeatErrorTotal.WithLabelValues().Inc()
-		}
-	} else {
-		for i := 0; i < len(datasourceIds); i++ {
-			err := models.AlertingEngineHeartbeatWithCluster(n.ctx, n.heartbeatConfig.Endpoint, n.heartbeatConfig.EngineName, datasourceIds[i])
-			if err != nil {
-				logger.Warningf("heartbeat with cluster %d err:%v", datasourceIds[i], err)
-				n.astats.CounterHeartbeatErrorTotal.WithLabelValues().Inc()
-			}
-		}
-	}
-
-	if len(datasourceIds) == 0 {
-		DatasourceHashRing.Clear(n.heartbeatConfig.EngineName)
-		for dsId := range localss {
-			delete(localss, dsId)
-		}
-	}
-
-	newDatasource := make(map[int64]struct{})
-	for i := 0; i < len(datasourceIds); i++ {
-		newDatasource[datasourceIds[i]] = struct{}{}
-		servers, err := n.ActiveServers(datasourceIds[i])
-		if err != nil {
-			logger.Warningf("hearbeat %d get active server err:%v", datasourceIds[i], err)
-			n.astats.CounterHeartbeatErrorTotal.WithLabelValues().Inc()
-			continue
-		}
-
-		sort.Strings(servers)
-		newss := strings.Join(servers, " ")
-
-		oldss, exists := localss[datasourceIds[i]]
-		if exists && oldss == newss {
-			continue
-		}
-
-		RebuildConsistentHashRing(fmt.Sprintf("%d", datasourceIds[i]), servers)
-		localss[datasourceIds[i]] = newss
-	}
-
-	for dsId := range localss {
-		if _, exists := newDatasource[dsId]; !exists {
-			delete(localss, dsId)
-			DatasourceHashRing.Del(fmt.Sprintf("%d", dsId))
-		}
-	}
-
-	// host 告警使用的是 hash ring
-	err = models.AlertingEngineHeartbeatWithCluster(n.ctx, n.heartbeatConfig.Endpoint, n.heartbeatConfig.EngineName, HostDatasource)
-	if err != nil {
-		logger.Warningf("heartbeat with cluster %s err:%v", "", err)
-		n.astats.CounterHeartbeatErrorTotal.WithLabelValues().Inc()
-	}
-
-	servers, err := n.ActiveServersByEngineName()
-	if err != nil {
-		logger.Warningf("hearbeat %d get active server err:%v", HostDatasource, err)
-		n.astats.CounterHeartbeatErrorTotal.WithLabelValues().Inc()
-		return nil
-	}
-
-	sort.Strings(servers)
-	newss := strings.Join(servers, " ")
-
-	oldss, exists := localHostServers[n.heartbeatConfig.EngineName]
-	if exists && oldss == newss {
-		return nil
-	}
-
-	RebuildConsistentHashRing(n.heartbeatConfig.EngineName, servers)
-	localHostServers[n.heartbeatConfig.EngineName] = newss
-
-	return nil
-}
-
-func (n *Naming) ActiveServers(datasourceId int64) ([]string, error) {
-	if datasourceId == -1 {
-		return nil, fmt.Errorf("cluster is empty")
-	}
-
-	if !n.ctx.IsCenter {
-		lst, err := poster.GetByUrls[[]string](n.ctx, "/v1/n9e/servers-active?dsid="+fmt.Sprintf("%d", datasourceId))
-		return lst, err
-	}
-
-	// 30秒内有心跳，就认为是活的
-	return models.AlertingEngineGetsInstances(n.ctx, "datasource_id = ? and clock > ?", datasourceId, time.Now().Unix()-30)
-}
-
-func (n *Naming) ActiveServersByEngineName() ([]string, error) {
-	if !n.ctx.IsCenter {
-		lst, err := poster.GetByUrls[[]string](n.ctx, "/v1/n9e/servers-active?engine_name="+n.heartbeatConfig.EngineName)
-		return lst, err
-	}
-
-	// 30秒内有心跳，就认为是活的
-	return models.AlertingEngineGetsInstances(n.ctx, "engine_cluster = ? and clock > ?", n.heartbeatConfig.EngineName, time.Now().Unix()-30)
-}

alert/naming/leader.go

@@ -1,28 +0,0 @@
-package naming
-
-import (
-	"sort"
-
-	"github.com/toolkits/pkg/logger"
-)
-
-func (n *Naming) IamLeader() bool {
-	if !n.ctx.IsCenter {
-		return false
-	}
-
-	servers, err := n.ActiveServersByEngineName()
-	if err != nil {
-		logger.Errorf("failed to get active servers: %v", err)
-		return false
-	}
-
-	if len(servers) == 0 {
-		logger.Errorf("active servers empty")
-		return false
-	}
-
-	sort.Strings(servers)
-
-	return n.heartbeatConfig.Endpoint == servers[0]
-}

alert/process/alert_cur_event.go

@@ -1,74 +0,0 @@
-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
-}

alert/process/process.go

@@ -1,601 +0,0 @@
-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/pushgw/writer"
-
-	"github.com/prometheus/prometheus/prompb"
-	"github.com/toolkits/pkg/logger"
-	"github.com/toolkits/pkg/str"
-)
-
-type EventMuteHookFunc func(event *models.AlertCurEvent) bool
-
-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 HandleEventFunc func(event *models.AlertCurEvent)
-
-type Processor struct {
-	datasourceId int64
-	EngineName   string
-
-	rule     *models.AlertRule
-	fires    *AlertCurEventMap
-	pendings *AlertCurEventMap
-	inhibit  bool
-
-	tagsMap    map[string]string
-	tagsArr    []string
-	target     string
-	targetNote string
-	groupName  string
-
-	alertRuleCache          *memsto.AlertRuleCacheType
-	TargetCache             *memsto.TargetCacheType
-	TargetsOfAlertRuleCache *memsto.TargetsOfAlertRuleCacheType
-	BusiGroupCache          *memsto.BusiGroupCacheType
-	alertMuteCache          *memsto.AlertMuteCacheType
-	datasourceCache         *memsto.DatasourceCacheType
-
-	ctx   *ctx.Context
-	Stats *astats.Stats
-
-	HandleFireEventHook    HandleEventFunc
-	HandleRecoverEventHook HandleEventFunc
-	EventMuteHook          EventMuteHookFunc
-}
-
-func (p *Processor) Key() string {
-	return common.RuleKey(p.datasourceId, p.rule.Id)
-}
-
-func (p *Processor) DatasourceId() int64 {
-	return p.datasourceId
-}
-
-func (p *Processor) Hash() string {
-	return str.MD5(fmt.Sprintf("%d_%d_%s_%d",
-		p.rule.Id,
-		p.rule.PromEvalInterval,
-		p.rule.RuleConfig,
-		p.datasourceId,
-	))
-}
-
-func NewProcessor(engineName string, rule *models.AlertRule, datasourceId int64, alertRuleCache *memsto.AlertRuleCacheType,
-	targetCache *memsto.TargetCacheType, targetsOfAlertRuleCache *memsto.TargetsOfAlertRuleCacheType,
-	busiGroupCache *memsto.BusiGroupCacheType, alertMuteCache *memsto.AlertMuteCacheType, datasourceCache *memsto.DatasourceCacheType, ctx *ctx.Context,
-	stats *astats.Stats) *Processor {
-
-	p := &Processor{
-		EngineName:   engineName,
-		datasourceId: datasourceId,
-		rule:         rule,
-
-		TargetCache:             targetCache,
-		TargetsOfAlertRuleCache: targetsOfAlertRuleCache,
-		BusiGroupCache:          busiGroupCache,
-		alertMuteCache:          alertMuteCache,
-		alertRuleCache:          alertRuleCache,
-		datasourceCache:         datasourceCache,
-
-		ctx:   ctx,
-		Stats: stats,
-
-		HandleFireEventHook:    func(event *models.AlertCurEvent) {},
-		HandleRecoverEventHook: func(event *models.AlertCurEvent) {},
-		EventMuteHook:          func(event *models.AlertCurEvent) bool { return false },
-	}
-
-	p.mayHandleGroup()
-	return p
-}
-
-func (p *Processor) Handle(anomalyPoints []common.AnomalyPoint, from string, inhibit bool) {
-	// 有可能rule的一些配置已经发生变化，比如告警接收人、callbacks等
-	// 这些信息的修改是不会引起worker restart的，但是确实会影响告警处理逻辑
-	// 所以，这里直接从memsto.AlertRuleCache中获取并覆盖
-	p.inhibit = inhibit
-	cachedRule := p.alertRuleCache.Get(p.rule.Id)
-	if cachedRule == nil {
-		logger.Errorf("rule not found %+v", anomalyPoints)
-		p.Stats.CounterRuleEvalErrorTotal.WithLabelValues(fmt.Sprintf("%v", p.DatasourceId()), "handle_event").Inc()
-		return
-	}
-
-	p.rule = cachedRule
-	now := time.Now().Unix()
-	alertingKeys := map[string]struct{}{}
-
-	// 根据 event 的 tag 将 events 分组，处理告警抑制的情况
-	eventsMap := make(map[string][]*models.AlertCurEvent)
-	for _, anomalyPoint := range anomalyPoints {
-		event := p.BuildEvent(anomalyPoint, from, now)
-		// 如果 event 被 mute 了,本质也是 fire 的状态,这里无论如何都添加到 alertingKeys 中,防止 fire 的事件自动恢复了
-		hash := event.Hash
-		alertingKeys[hash] = struct{}{}
-		isMuted, detail := mute.IsMuted(cachedRule, event, p.TargetCache, p.alertMuteCache)
-		if isMuted {
-			p.Stats.CounterMuteTotal.WithLabelValues(event.GroupName).Inc()
-			logger.Debugf("rule_eval:%s event:%v is muted, detail:%s", p.Key(), event, detail)
-			continue
-		}
-
-		if p.EventMuteHook(event) {
-			p.Stats.CounterMuteTotal.WithLabelValues(event.GroupName).Inc()
-			logger.Debugf("rule_eval:%s event:%v is muted by hook", p.Key(), event)
-			continue
-		}
-
-		tagHash := TagHash(anomalyPoint)
-		eventsMap[tagHash] = append(eventsMap[tagHash], event)
-	}
-
-	for _, events := range eventsMap {
-		p.handleEvent(events)
-	}
-
-	p.HandleRecover(alertingKeys, now, inhibit)
-}
-
-func (p *Processor) BuildEvent(anomalyPoint common.AnomalyPoint, from string, now int64) *models.AlertCurEvent {
-	p.fillTags(anomalyPoint)
-	p.mayHandleIdent()
-	hash := Hash(p.rule.Id, p.datasourceId, anomalyPoint)
-	ds := p.datasourceCache.GetById(p.datasourceId)
-	var dsName string
-	if ds != nil {
-		dsName = ds.Name
-	}
-
-	event := p.rule.GenerateNewEvent(p.ctx)
-
-	bg := p.BusiGroupCache.GetByBusiGroupId(p.rule.GroupId)
-	if bg != nil {
-		event.GroupName = bg.Name
-	}
-
-	event.TriggerTime = anomalyPoint.Timestamp
-	event.TagsMap = p.tagsMap
-	event.DatasourceId = p.datasourceId
-	event.Cluster = dsName
-	event.Hash = hash
-	event.TargetIdent = p.target
-	event.TargetNote = p.targetNote
-	event.TriggerValue = anomalyPoint.ReadableValue()
-	event.TriggerValues = anomalyPoint.Values
-	event.TagsJSON = p.tagsArr
-	event.Tags = strings.Join(p.tagsArr, ",,")
-	event.IsRecovered = false
-	event.Callbacks = p.rule.Callbacks
-	event.CallbacksJSON = p.rule.CallbacksJSON
-	event.Annotations = p.rule.Annotations
-	event.AnnotationsJSON = make(map[string]string)
-	event.RuleConfig = p.rule.RuleConfig
-	event.RuleConfigJson = p.rule.RuleConfigJson
-	event.Severity = anomalyPoint.Severity
-	event.ExtraConfig = p.rule.ExtraConfigJSON
-	event.PromQl = anomalyPoint.Query
-
-	if event.TriggerValues != "" && strings.Count(event.TriggerValues, "$") > 1 {
-		// TriggerValues 有多个变量，将多个变量都放到 TriggerValue 中
-		event.TriggerValue = event.TriggerValues
-	}
-
-	if from == "inner" {
-		event.LastEvalTime = now
-	} else {
-		event.LastEvalTime = event.TriggerTime
-	}
-
-	// 生成事件之后，立马进程 relabel 处理
-	Relabel(p.rule, event)
-	return event
-}
-
-func Relabel(rule *models.AlertRule, event *models.AlertCurEvent) {
-	if rule == nil {
-		return
-	}
-
-	// need to keep the original label
-	event.OriginalTags = event.Tags
-	event.OriginalTagsJSON = make([]string, len(event.TagsJSON))
-
-	labels := make([]prompb.Label, len(event.TagsJSON))
-	for i, tag := range event.TagsJSON {
-		label := strings.Split(tag, "=")
-		if len(label) != 2 {
-			logger.Errorf("event%+v relabel: the label length is not 2:%v", event, label)
-			continue
-		}
-		event.OriginalTagsJSON[i] = tag
-		labels[i] = prompb.Label{Name: label[0], Value: label[1]}
-	}
-
-	for i := 0; i < len(rule.EventRelabelConfig); i++ {
-		if rule.EventRelabelConfig[i].Replacement == "" {
-			rule.EventRelabelConfig[i].Replacement = "$1"
-		}
-
-		if rule.EventRelabelConfig[i].Separator == "" {
-			rule.EventRelabelConfig[i].Separator = ";"
-		}
-
-		if rule.EventRelabelConfig[i].Regex == "" {
-			rule.EventRelabelConfig[i].Regex = "(.*)"
-		}
-	}
-
-	// relabel process
-	relabels := writer.Process(labels, rule.EventRelabelConfig...)
-	event.TagsJSON = make([]string, len(relabels))
-	event.TagsMap = make(map[string]string, len(relabels))
-	for i, label := range relabels {
-		event.TagsJSON[i] = fmt.Sprintf("%s=%s", label.Name, label.Value)
-		event.TagsMap[label.Name] = label.Value
-	}
-	event.Tags = strings.Join(event.TagsJSON, ",,")
-}
-
-func (p *Processor) HandleRecover(alertingKeys map[string]struct{}, now int64, inhibit bool) {
-	for _, hash := range p.pendings.Keys() {
-		if _, has := alertingKeys[hash]; has {
-			continue
-		}
-		p.pendings.Delete(hash)
-	}
-
-	hashArr := make([]string, 0, len(alertingKeys))
-	for hash := range p.fires.GetAll() {
-		if _, has := alertingKeys[hash]; has {
-			continue
-		}
-
-		hashArr = append(hashArr, hash)
-	}
-	p.HandleRecoverEvent(hashArr, now, inhibit)
-
-}
-
-func (p *Processor) HandleRecoverEvent(hashArr []string, now int64, inhibit bool) {
-	cachedRule := p.rule
-	if cachedRule == nil {
-		return
-	}
-
-	if !inhibit {
-		for _, hash := range hashArr {
-			p.RecoverSingle(hash, now, nil)
-		}
-		return
-	}
-
-	eventMap := make(map[string]models.AlertCurEvent)
-	for _, hash := range hashArr {
-		event, has := p.fires.Get(hash)
-		if !has {
-			continue
-		}
-
-		e, exists := eventMap[event.Tags]
-		if !exists {
-			eventMap[event.Tags] = *event
-			continue
-		}
-
-		if e.Severity > event.Severity {
-			// hash 对应的恢复事件的被抑制了，把之前的事件删除
-			p.fires.Delete(e.Hash)
-			p.pendings.Delete(e.Hash)
-			models.AlertCurEventDelByHash(p.ctx, e.Hash)
-			eventMap[event.Tags] = *event
-		}
-	}
-
-	for _, event := range eventMap {
-		p.RecoverSingle(event.Hash, now, nil)
-	}
-}
-
-func (p *Processor) RecoverSingle(hash string, now int64, value *string, values ...string) {
-	cachedRule := p.rule
-	if cachedRule == nil {
-		return
-	}
-
-	event, has := p.fires.Get(hash)
-	if !has {
-		return
-	}
-	// 如果配置了留观时长，就不能立马恢复了
-	if cachedRule.RecoverDuration > 0 && now-event.LastEvalTime < cachedRule.RecoverDuration {
-		logger.Debugf("rule_eval:%s event:%v not recover", p.Key(), event)
-		return
-	}
-	if value != nil {
-		event.TriggerValue = *value
-		if len(values) > 0 {
-			event.TriggerValues = values[0]
-		}
-	}
-
-	// 没查到触发阈值的vector，姑且就认为这个vector的值恢复了
-	// 我确实无法分辨，是prom中有值但是未满足阈值所以没返回，还是prom中确实丢了一些点导致没有数据可以返回，尴尬
-	p.fires.Delete(hash)
-	p.pendings.Delete(hash)
-
-	// 可能是因为调整了promql才恢复的，所以事件里边要体现最新的promql，否则用户会比较困惑
-	// 当然，其实rule的各个字段都可能发生变化了，都更新一下吧
-	cachedRule.UpdateEvent(event)
-	event.IsRecovered = true
-	event.LastEvalTime = now
-
-	p.HandleRecoverEventHook(event)
-	p.pushEventToQueue(event)
-}
-
-func (p *Processor) handleEvent(events []*models.AlertCurEvent) {
-	var fireEvents []*models.AlertCurEvent
-	// severity 初始为 4, 一定为遇到比自己优先级高的事件
-	severity := 4
-	for _, event := range events {
-		if event == nil {
-			continue
-		}
-		if p.rule.PromForDuration == 0 {
-			fireEvents = append(fireEvents, event)
-			if severity > event.Severity {
-				severity = event.Severity
-			}
-			continue
-		}
-
-		var preTriggerTime int64
-		preEvent, has := p.pendings.Get(event.Hash)
-		if has {
-			p.pendings.UpdateLastEvalTime(event.Hash, event.LastEvalTime)
-			preTriggerTime = preEvent.TriggerTime
-		} else {
-			p.pendings.Set(event.Hash, event)
-			preTriggerTime = event.TriggerTime
-		}
-
-		if event.LastEvalTime-preTriggerTime+int64(event.PromEvalInterval) >= int64(p.rule.PromForDuration) {
-			fireEvents = append(fireEvents, event)
-			if severity > event.Severity {
-				severity = event.Severity
-			}
-			continue
-		}
-	}
-
-	p.inhibitEvent(fireEvents, severity)
-}
-
-func (p *Processor) inhibitEvent(events []*models.AlertCurEvent, highSeverity int) {
-	for _, event := range events {
-		if p.inhibit && event.Severity > highSeverity {
-			logger.Debugf("rule_eval:%s event:%+v inhibit highSeverity:%d", p.Key(), event, highSeverity)
-			continue
-		}
-		p.fireEvent(event)
-	}
-}
-
-func (p *Processor) fireEvent(event *models.AlertCurEvent) {
-	// As p.rule maybe outdated, use rule from cache
-	cachedRule := p.rule
-	if cachedRule == nil {
-		return
-	}
-
-	logger.Debugf("rule_eval:%s event:%+v fire", p.Key(), event)
-	if fired, has := p.fires.Get(event.Hash); has {
-		p.fires.UpdateLastEvalTime(event.Hash, event.LastEvalTime)
-		event.FirstTriggerTime = fired.FirstTriggerTime
-		p.HandleFireEventHook(event)
-
-		if cachedRule.NotifyRepeatStep == 0 {
-			logger.Debugf("rule_eval:%s event:%+v repeat is zero nothing to do", p.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
-				p.pushEventToQueue(event)
-			} else {
-				// 有最大发送次数的限制，就要看已经发了几次了，是否达到了最大发送次数
-				if fired.NotifyCurNumber >= cachedRule.NotifyMaxNumber {
-					logger.Debugf("rule_eval:%s event:%+v reach max number", p.Key(), event)
-					return
-				} else {
-					event.NotifyCurNumber = fired.NotifyCurNumber + 1
-					p.pushEventToQueue(event)
-				}
-			}
-		}
-	} else {
-		event.NotifyCurNumber = 1
-		event.FirstTriggerTime = event.TriggerTime
-		p.HandleFireEventHook(event)
-		p.pushEventToQueue(event)
-	}
-}
-
-func (p *Processor) pushEventToQueue(e *models.AlertCurEvent) {
-	if !e.IsRecovered {
-		e.LastSentTime = e.LastEvalTime
-		p.fires.Set(e.Hash, e)
-	}
-
-	dispatch.LogEvent(e, "push_queue")
-	if !queue.EventQueue.PushFront(e) {
-		logger.Warningf("event_push_queue: queue is full, event:%+v", e)
-		p.Stats.CounterRuleEvalErrorTotal.WithLabelValues(fmt.Sprintf("%v", p.DatasourceId()), "push_event_queue").Inc()
-	}
-}
-
-func (p *Processor) RecoverAlertCurEventFromDb() {
-	p.pendings = NewAlertCurEventMap(nil)
-
-	curEvents, err := models.AlertCurEventGetByRuleIdAndDsId(p.ctx, p.rule.Id, p.datasourceId)
-	if err != nil {
-		logger.Errorf("recover event from db for rule:%s failed, err:%s", p.Key(), err)
-		p.Stats.CounterRuleEvalErrorTotal.WithLabelValues(fmt.Sprintf("%v", p.DatasourceId()), "get_recover_event").Inc()
-		p.fires = NewAlertCurEventMap(nil)
-		return
-	}
-
-	fireMap := make(map[string]*models.AlertCurEvent)
-	for _, event := range curEvents {
-		if event.Cate == models.HOST {
-			target, exists := p.TargetCache.Get(event.TargetIdent)
-			if exists && target.EngineName != p.EngineName && !(p.ctx.IsCenter && target.EngineName == "") {
-				// 如果是 host rule，且 target 的 engineName 不是当前的 engineName 或者是中心机房 target EngineName 为空，就跳过
-				continue
-			}
-		}
-
-		event.DB2Mem()
-		fireMap[event.Hash] = event
-	}
-
-	p.fires = NewAlertCurEventMap(fireMap)
-}
-
-func (p *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 p.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(p.rule.Id)).Funcs(template.FuncMap(tplx.TemplateFuncMap)).Parse(text)
-		if err != nil {
-			tagValue = fmt.Sprintf("parse tag value failed, err:%s", err)
-			tagsMap[arr[0]] = tagValue
-			continue
-		}
-
-		var body bytes.Buffer
-		err = t.Execute(&body, e)
-		if err != nil {
-			tagValue = fmt.Sprintf("parse tag value failed, err:%s", err)
-			tagsMap[arr[0]] = tagValue
-			continue
-		}
-
-		tagsMap[arr[0]] = body.String()
-	}
-
-	tagsMap["rulename"] = p.rule.Name
-	p.tagsMap = tagsMap
-
-	// handle tagsArr
-	p.tagsArr = labelMapToArr(tagsMap)
-}
-
-func (p *Processor) mayHandleIdent() {
-	// handle ident
-	if ident, has := p.tagsMap["ident"]; has {
-		if target, exists := p.TargetCache.Get(ident); exists {
-			p.target = target.Ident
-			p.targetNote = target.Note
-		} else {
-			p.target = ident
-			p.targetNote = ""
-		}
-	} else {
-		p.target = ""
-		p.targetNote = ""
-	}
-}
-
-func (p *Processor) mayHandleGroup() {
-	// handle bg
-	bg := p.BusiGroupCache.GetByBusiGroupId(p.rule.GroupId)
-	if bg != nil {
-		p.groupName = bg.Name
-	}
-}
-
-func (p *Processor) DeleteProcessEvent(hash string) {
-	p.fires.Delete(hash)
-	p.pendings.Delete(hash)
-}
-
-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_%s", ruleId, vector.Labels.String(), datasourceId, vector.Severity, vector.Query))
-}
-
-func TagHash(vector common.AnomalyPoint) string {
-	return str.MD5(vector.Labels.String())
-}

alert/queue/queue.go

@@ -1,18 +0,0 @@
-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()))
-	}
-}

alert/record/prom_rule.go

@@ -1,117 +0,0 @@
-package record
-
-import (
-	"context"
-	"fmt"
-	"strings"
-	"time"
-
-	"github.com/ccfos/nightingale/v6/alert/astats"
-	"github.com/ccfos/nightingale/v6/models"
-	"github.com/ccfos/nightingale/v6/prom"
-	"github.com/ccfos/nightingale/v6/pushgw/writer"
-	"github.com/robfig/cron/v3"
-
-	"github.com/toolkits/pkg/logger"
-	"github.com/toolkits/pkg/str"
-)
-
-type RecordRuleContext struct {
-	datasourceId int64
-	quit         chan struct{}
-
-	scheduler   *cron.Cron
-	rule        *models.RecordingRule
-	promClients *prom.PromClientMap
-	stats       *astats.Stats
-}
-
-func NewRecordRuleContext(rule *models.RecordingRule, datasourceId int64, promClients *prom.PromClientMap, writers *writer.WritersType, stats *astats.Stats) *RecordRuleContext {
-	rrc := &RecordRuleContext{
-		datasourceId: datasourceId,
-		quit:         make(chan struct{}),
-		rule:         rule,
-		promClients:  promClients,
-		stats:        stats,
-	}
-
-	if rule.CronPattern == "" && rule.PromEvalInterval != 0 {
-		rule.CronPattern = fmt.Sprintf("@every %ds", rule.PromEvalInterval)
-	}
-
-	rrc.scheduler = cron.New(cron.WithSeconds())
-	_, err := rrc.scheduler.AddFunc(rule.CronPattern, func() {
-		rrc.Eval()
-	})
-
-	if err != nil {
-		logger.Errorf("add cron pattern error: %v", err)
-	}
-
-	return rrc
-}
-
-func (rrc *RecordRuleContext) Key() string {
-	return fmt.Sprintf("record-%d-%d", rrc.datasourceId, rrc.rule.Id)
-}
-
-func (rrc *RecordRuleContext) Hash() string {
-	return str.MD5(fmt.Sprintf("%d_%s_%s_%d",
-		rrc.rule.Id,
-		rrc.rule.CronPattern,
-		rrc.rule.PromQl,
-		rrc.datasourceId,
-	))
-}
-
-func (rrc *RecordRuleContext) Prepare() {}
-
-func (rrc *RecordRuleContext) Start() {
-	logger.Infof("eval:%s started", rrc.Key())
-	rrc.scheduler.Start()
-}
-
-func (rrc *RecordRuleContext) Eval() {
-	rrc.stats.CounterRecordEval.WithLabelValues(fmt.Sprintf("%d", rrc.datasourceId)).Inc()
-	promql := strings.TrimSpace(rrc.rule.PromQl)
-	if promql == "" {
-		logger.Errorf("eval:%s promql is blank", rrc.Key())
-		return
-	}
-
-	if rrc.promClients.IsNil(rrc.datasourceId) {
-		logger.Errorf("eval:%s reader client is nil", rrc.Key())
-		rrc.stats.CounterRecordEvalErrorTotal.WithLabelValues(fmt.Sprintf("%d", rrc.datasourceId)).Inc()
-		return
-	}
-
-	value, warnings, err := rrc.promClients.GetCli(rrc.datasourceId).Query(context.Background(), promql, time.Now())
-	if err != nil {
-		logger.Errorf("eval:%s promql:%s, error:%v", rrc.Key(), promql, err)
-		rrc.stats.CounterRecordEvalErrorTotal.WithLabelValues(fmt.Sprintf("%d", rrc.datasourceId)).Inc()
-		return
-	}
-
-	if len(warnings) > 0 {
-		logger.Errorf("eval:%s promql:%s, warnings:%v", rrc.Key(), promql, warnings)
-		rrc.stats.CounterRecordEvalErrorTotal.WithLabelValues(fmt.Sprintf("%d", rrc.datasourceId)).Inc()
-		return
-	}
-
-	ts := ConvertToTimeSeries(value, rrc.rule)
-	if len(ts) != 0 {
-		err := rrc.promClients.GetWriterCli(rrc.datasourceId).Write(ts)
-		if err != nil {
-			logger.Errorf("eval:%s promql:%s, error:%v", rrc.Key(), promql, err)
-			rrc.stats.CounterRecordEvalErrorTotal.WithLabelValues(fmt.Sprintf("%d", rrc.datasourceId)).Inc()
-		}
-	}
-}
-
-func (rrc *RecordRuleContext) Stop() {
-	logger.Infof("%s stopped", rrc.Key())
-
-	c := rrc.scheduler.Stop()
-	<-c.Done()
-	close(rrc.quit)
-}

alert/record/sample.go

@@ -1,122 +0,0 @@
-package record
-
-import (
-	"math"
-	"strings"
-	"time"
-
-	"github.com/ccfos/nightingale/v6/models"
-
-	"github.com/prometheus/common/model"
-	"github.com/prometheus/prometheus/prompb"
-)
-
-const (
-	LabelName = "__name__"
-)
-
-func ConvertToTimeSeries(value model.Value, rule *models.RecordingRule) (lst []prompb.TimeSeries) {
-	switch value.Type() {
-	case model.ValVector:
-		items, ok := value.(model.Vector)
-		if !ok {
-			return
-		}
-
-		for _, item := range items {
-			if math.IsNaN(float64(item.Value)) {
-				continue
-			}
-			s := prompb.Sample{}
-			s.Timestamp = time.Unix(item.Timestamp.Unix(), 0).UnixNano() / 1e6
-			s.Value = float64(item.Value)
-			l := labelsToLabelsProto(item.Metric, rule)
-			lst = append(lst, prompb.TimeSeries{
-				Labels:  l,
-				Samples: []prompb.Sample{s},
-			})
-		}
-	case model.ValMatrix:
-		items, ok := value.(model.Matrix)
-		if !ok {
-			return
-		}
-
-		for _, item := range items {
-			if len(item.Values) == 0 {
-				return
-			}
-
-			last := item.Values[len(item.Values)-1]
-
-			if math.IsNaN(float64(last.Value)) {
-				continue
-			}
-			l := labelsToLabelsProto(item.Metric, rule)
-			var slst []prompb.Sample
-			for _, v := range item.Values {
-				if math.IsNaN(float64(v.Value)) {
-					continue
-				}
-				slst = append(slst, prompb.Sample{
-					Timestamp: time.Unix(v.Timestamp.Unix(), 0).UnixNano() / 1e6,
-					Value:     float64(v.Value),
-				})
-			}
-			lst = append(lst, prompb.TimeSeries{
-				Labels:  l,
-				Samples: slst,
-			})
-		}
-	case model.ValScalar:
-		item, ok := value.(*model.Scalar)
-		if !ok {
-			return
-		}
-
-		if math.IsNaN(float64(item.Value)) {
-			return
-		}
-
-		lst = append(lst, prompb.TimeSeries{
-			Labels:  nil,
-			Samples: []prompb.Sample{{Value: float64(item.Value), Timestamp: time.Unix(item.Timestamp.Unix(), 0).UnixNano() / 1e6}},
-		})
-	default:
-		return
-	}
-
-	return
-}
-
-func labelsToLabelsProto(labels model.Metric, rule *models.RecordingRule) (result []prompb.Label) {
-	//name
-	nameLs := prompb.Label{
-		Name:  LabelName,
-		Value: rule.Name,
-	}
-	result = append(result, nameLs)
-	for k, v := range labels {
-		if k == LabelName {
-			continue
-		}
-		if model.LabelNameRE.MatchString(string(k)) {
-			result = append(result, prompb.Label{
-				Name:  string(k),
-				Value: string(v),
-			})
-		}
-	}
-	if len(rule.AppendTagsJSON) != 0 {
-		for _, v := range rule.AppendTagsJSON {
-			index := strings.Index(v, "=")
-			if model.LabelNameRE.MatchString(v[:index]) {
-				result = append(result, prompb.Label{
-					Name:  v[:index],
-					Value: v[index+1:],
-				})
-			}
-		}
-	}
-	return result
-}

alert/record/scheduler.go

@@ -1,95 +0,0 @@
-package record
-
-import (
-	"context"
-	"fmt"
-	"strconv"
-	"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(strconv.FormatInt(dsId, 10), fmt.Sprintf("%d", rule.Id), s.aconf.Heartbeat.Endpoint) {
-				continue
-			}
-
-			recordRule := NewRecordRuleContext(rule, dsId, s.promClients, s.writers, s.stats)
-			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)
-		}
-	}
-}

alert/router/router.go

@@ -1,79 +0,0 @@
-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,
-		AlertMuteCache:     amc,
-		TargetCache:        tc,
-		BusiGroupCache:     bgc,
-		AlertStats:         astats,
-		Ctx:                ctx,
-		ExternalProcessors: externalProcessors,
-	}
-}
-
-func (rt *Router) Config(r *gin.Engine) {
-	if !rt.HTTP.APIForService.Enable {
-		return
-	}
-
-	service := r.Group("/v1/n9e")
-	if len(rt.HTTP.APIForService.BasicAuth) > 0 {
-		service.Use(gin.BasicAuth(rt.HTTP.APIForService.BasicAuth))
-	}
-	service.POST("/event", rt.pushEventToQueue)
-	service.POST("/event-persist", rt.eventPersist)
-	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()}})
-	}
-}

alert/router/router_event.go

@@ -1,148 +0,0 @@
-package router
-
-import (
-	"fmt"
-	"strconv"
-	"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"
-)
-
-func (rt *Router) pushEventToQueue(c *gin.Context) {
-	var event *models.AlertCurEvent
-	ginx.BindJSON(c, &event)
-	if event.RuleId == 0 {
-		ginx.Bomb(200, "event is illegal")
-	}
-
-	event.TagsMap = make(map[string]string)
-	for i := 0; i < len(event.TagsJSON); i++ {
-		pair := strings.TrimSpace(event.TagsJSON[i])
-		if pair == "" {
-			continue
-		}
-
-		arr := strings.Split(pair, "=")
-		if len(arr) != 2 {
-			continue
-		}
-
-		event.TagsMap[arr[0]] = arr[1]
-	}
-
-	if mute.EventMuteStrategy(event, rt.AlertMuteCache) {
-		logger.Infof("event_muted: rule_id=%d %s", event.RuleId, event.Hash)
-		ginx.NewRender(c).Message(nil)
-		return
-	}
-
-	if err := event.ParseRule("rule_name"); err != nil {
-		event.RuleName = fmt.Sprintf("failed to parse rule name: %v", err)
-	}
-
-	if err := event.ParseRule("rule_note"); err != nil {
-		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, ";")
-		event.Tags = strings.ReplaceAll(event.RuleNote, " ", ",,")
-		event.TagsJSON = strings.Split(event.Tags, ",,")
-	} else {
-		event.Tags = strings.Join(event.TagsJSON, ",,")
-	}
-
-	event.Callbacks = strings.Join(event.CallbacksJSON, " ")
-	event.NotifyChannels = strings.Join(event.NotifyChannelsJSON, " ")
-	event.NotifyGroups = strings.Join(event.NotifyGroupsJSON, " ")
-
-	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)
-	}
-	ginx.NewRender(c).Message(nil)
-}
-
-func (rt *Router) eventPersist(c *gin.Context) {
-	var event *models.AlertCurEvent
-	ginx.BindJSON(c, &event)
-	event.FE2DB()
-	err := models.EventPersist(rt.Ctx, event)
-	ginx.NewRender(c).Data(event.Id, err)
-}
-
-type eventForm struct {
-	Alert         bool                  `json:"alert"`
-	AnomalyPoints []common.AnomalyPoint `json:"vectors"`
-	RuleId        int64                 `json:"rule_id"`
-	DatasourceId  int64                 `json:"datasource_id"`
-	Inhibit       bool                  `json:"inhibit"`
-}
-
-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.DatasourceHashRing.GetNode(strconv.FormatInt(events[i].DatasourceId, 10), 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 != rt.Alert.Heartbeat.Endpoint {
-			err := forwardEvent(events[i], node)
-			if err != nil {
-				logger.Warningf("event:%+v forward err:%v", events[i], err)
-				ginx.Bomb(200, "event forward error")
-			}
-			continue
-		}
-
-		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 ruleWorker.Handle(events[i].AnomalyPoints, "http", events[i].Inhibit)
-		} else {
-			for _, vector := range events[i].AnomalyPoints {
-				readableString := vector.ReadableValue()
-				go ruleWorker.RecoverSingle(process.Hash(events[i].RuleId, events[i].DatasourceId, vector), vector.Timestamp, &readableString)
-			}
-		}
-	}
-	ginx.NewRender(c).Message(nil)
-}
-
-// event 不归本实例处理，转发给对应的实例
-func forwardEvent(event *eventForm, instance string) error {
-	ur := fmt.Sprintf("http://%s/v1/n9e/make-event", instance)
-	res, code, err := poster.PostJSON(ur, time.Second*5, []*eventForm{event}, 3)
-	if err != nil {
-		return err
-	}
-	logger.Infof("forward event: result=succ url=%s code=%d event:%v response=%s", ur, code, event, string(res))
-	return nil
-}

alert/sender/callback.go

@@ -1,183 +0,0 @@
-package sender
-
-import (
-	"html/template"
-	"net/url"
-	"strings"
-	"time"
-
-	"github.com/ccfos/nightingale/v6/alert/astats"
-	"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/poster"
-
-	"github.com/toolkits/pkg/logger"
-)
-
-type (
-	// CallBacker 进行回调的接口
-	CallBacker interface {
-		CallBack(ctx CallBackContext)
-	}
-
-	// CallBackContext 回调时所需的上下文
-	CallBackContext struct {
-		Ctx         *ctx.Context
-		CallBackURL string
-		Users       []*models.User
-		Rule        *models.AlertRule
-		Events      []*models.AlertCurEvent
-		Stats       *astats.Stats
-		BatchSend   bool
-	}
-
-	DefaultCallBacker struct{}
-)
-
-func BuildCallBackContext(ctx *ctx.Context, callBackURL string, rule *models.AlertRule, events []*models.AlertCurEvent,
-	uids []int64, userCache *memsto.UserCacheType, batchSend bool, stats *astats.Stats) CallBackContext {
-	users := userCache.GetByUserIds(uids)
-
-	newCallBackUrl, _ := events[0].ParseURL(callBackURL)
-	return CallBackContext{
-		Ctx:         ctx,
-		CallBackURL: newCallBackUrl,
-		Rule:        rule,
-		Events:      events,
-		Users:       users,
-		BatchSend:   batchSend,
-		Stats:       stats,
-	}
-}
-
-func ExtractAtsParams(rawURL string) []string {
-	ans := make([]string, 0, 1)
-	parsedURL, err := url.Parse(rawURL)
-	if err != nil {
-		logger.Errorf("ExtractAtsParams(url=%s), err: %v", rawURL, err)
-		return ans
-	}
-
-	queryParams := parsedURL.Query()
-	atParam := queryParams.Get("ats")
-	if atParam == "" {
-		return ans
-	}
-
-	// Split the atParam by comma and return the result as a slice
-	return strings.Split(atParam, ",")
-}
-
-func NewCallBacker(
-	key string,
-	targetCache *memsto.TargetCacheType,
-	userCache *memsto.UserCacheType,
-	taskTplCache *memsto.TaskTplCache,
-	tpls map[string]*template.Template,
-) CallBacker {
-
-	switch key {
-	case models.IbexDomain: // Distribute to Ibex
-		return &IbexCallBacker{
-			targetCache:  targetCache,
-			userCache:    userCache,
-			taskTplCache: taskTplCache,
-		}
-	case models.DefaultDomain: // default callback
-		return &DefaultCallBacker{}
-	case models.DingtalkDomain:
-		return &DingtalkSender{tpl: tpls[models.Dingtalk]}
-	case models.WecomDomain:
-		return &WecomSender{tpl: tpls[models.Wecom]}
-	case models.FeishuDomain:
-		return &FeishuSender{tpl: tpls[models.Feishu]}
-	case models.FeishuCardDomain:
-		return &FeishuCardSender{tpl: tpls[models.FeishuCard]}
-	//case models.Mm:
-	//	return &MmSender{tpl: tpls[models.Mm]}
-	case models.TelegramDomain:
-		return &TelegramSender{tpl: tpls[models.Telegram]}
-	case models.LarkDomain:
-		return &LarkSender{tpl: tpls[models.Lark]}
-	case models.LarkCardDomain:
-		return &LarkCardSender{tpl: tpls[models.LarkCard]}
-	}
-
-	return nil
-}
-
-func (c *DefaultCallBacker) CallBack(ctx CallBackContext) {
-	if len(ctx.CallBackURL) == 0 || len(ctx.Events) == 0 {
-		return
-	}
-
-	event := ctx.Events[0]
-
-	if ctx.BatchSend {
-		webhookConf := &models.Webhook{
-			Type:          models.RuleCallback,
-			Enable:        true,
-			Url:           ctx.CallBackURL,
-			Timeout:       5,
-			RetryCount:    3,
-			RetryInterval: 10,
-			Batch:         1000,
-		}
-
-		PushCallbackEvent(webhookConf, event, ctx.Stats)
-		return
-	}
-
-	ctx.Stats.AlertNotifyTotal.WithLabelValues("rule_callback").Inc()
-	resp, code, err := poster.PostJSON(ctx.CallBackURL, 5*time.Second, event, 3)
-	if err != nil {
-		logger.Errorf("event_callback_fail(rule_id=%d url=%s), event:%+v, resp: %s, err: %v, code: %d",
-			event.RuleId, ctx.CallBackURL, event, string(resp), err, code)
-		ctx.Stats.AlertNotifyErrorTotal.WithLabelValues("rule_callback").Inc()
-	} else {
-		logger.Infof("event_callback_succ(rule_id=%d url=%s), event:%+v, resp: %s, code: %d",
-			event.RuleId, ctx.CallBackURL, event, string(resp), code)
-	}
-}
-
-func doSend(url string, body interface{}, channel string, stats *astats.Stats) {
-	stats.AlertNotifyTotal.WithLabelValues(channel).Inc()
-
-	res, code, err := poster.PostJSON(url, time.Second*5, body, 3)
-	if err != nil {
-		logger.Errorf("%s_sender: result=fail url=%s code=%d error=%v req:%v response=%s", channel, url, code, err, body, string(res))
-		stats.AlertNotifyErrorTotal.WithLabelValues(channel).Inc()
-	} else {
-		logger.Infof("%s_sender: result=succ url=%s code=%d req:%v response=%s", channel, url, code, body, string(res))
-	}
-}
-
-type TaskCreateReply struct {
-	Err string `json:"err"`
-	Dat int64  `json:"dat"` // task.id
-}
-
-func PushCallbackEvent(webhook *models.Webhook, event *models.AlertCurEvent, stats *astats.Stats) {
-	CallbackEventQueueLock.RLock()
-	queue := CallbackEventQueue[webhook.Url]
-	CallbackEventQueueLock.RUnlock()
-
-	if queue == nil {
-		queue = &WebhookQueue{
-			list:    NewSafeListLimited(QueueMaxSize),
-			closeCh: make(chan struct{}),
-		}
-
-		CallbackEventQueueLock.Lock()
-		CallbackEventQueue[webhook.Url] = queue
-		CallbackEventQueueLock.Unlock()
-
-		StartConsumer(queue, webhook.Batch, webhook, stats)
-	}
-
-	succ := queue.list.PushFront(event)
-	if !succ {
-		logger.Warningf("Write channel(%s) full, current channel size: %d event:%v", webhook.Url, queue.list.Len(), event)
-	}
-}

alert/sender/dingtalk.go

@@ -1,122 +0,0 @@
-package sender
-
-import (
-	"github.com/ccfos/nightingale/v6/models"
-	"html/template"
-	"strings"
-)
-
-type dingtalkMarkdown struct {
-	Title string `json:"title"`
-	Text  string `json:"text"`
-}
-
-type dingtalkAt struct {
-	AtMobiles []string `json:"atMobiles"`
-	IsAtAll   bool     `json:"isAtAll"`
-}
-
-type dingtalk struct {
-	Msgtype  string           `json:"msgtype"`
-	Markdown dingtalkMarkdown `json:"markdown"`
-	At       dingtalkAt       `json:"at"`
-}
-
-var (
-	_ CallBacker = (*DingtalkSender)(nil)
-)
-
-type DingtalkSender struct {
-	tpl *template.Template
-}
-
-func (ds *DingtalkSender) Send(ctx MessageContext) {
-	if len(ctx.Users) == 0 || len(ctx.Events) == 0 {
-		return
-	}
-
-	urls, ats := ds.extract(ctx.Users)
-	if len(urls) == 0 {
-		return
-	}
-	message := BuildTplMessage(models.Dingtalk, ds.tpl, ctx.Events)
-
-	for _, url := range urls {
-		var body dingtalk
-		// NoAt in url
-		if strings.Contains(url, "noat=1") {
-			body = dingtalk{
-				Msgtype: "markdown",
-				Markdown: dingtalkMarkdown{
-					Title: ctx.Events[0].RuleName,
-					Text:  message,
-				},
-			}
-		} else {
-			body = dingtalk{
-				Msgtype: "markdown",
-				Markdown: dingtalkMarkdown{
-					Title: ctx.Events[0].RuleName,
-					Text:  message + "\n" + strings.Join(ats, " "),
-				},
-				At: dingtalkAt{
-					AtMobiles: ats,
-					IsAtAll:   false,
-				},
-			}
-		}
-
-		doSend(url, body, models.Dingtalk, ctx.Stats)
-	}
-}
-
-func (ds *DingtalkSender) CallBack(ctx CallBackContext) {
-	if len(ctx.Events) == 0 || len(ctx.CallBackURL) == 0 {
-		return
-	}
-
-	body := dingtalk{
-		Msgtype: "markdown",
-		Markdown: dingtalkMarkdown{
-			Title: ctx.Events[0].RuleName,
-		},
-	}
-
-	ats := ExtractAtsParams(ctx.CallBackURL)
-	message := BuildTplMessage(models.Dingtalk, ds.tpl, ctx.Events)
-
-	if len(ats) > 0 {
-		body.Markdown.Text = message + "\n@" + strings.Join(ats, "@")
-		body.At = dingtalkAt{
-			AtMobiles: ats,
-			IsAtAll:   false,
-		}
-	} else {
-		// NoAt in url
-		body.Markdown.Text = message
-	}
-
-	doSend(ctx.CallBackURL, body, models.Dingtalk, ctx.Stats)
-
-	ctx.Stats.AlertNotifyTotal.WithLabelValues("rule_callback").Inc()
-}
-
-// extract urls and ats from Users
-func (ds *DingtalkSender) extract(users []*models.User) ([]string, []string) {
-	urls := make([]string, 0, len(users))
-	ats := make([]string, 0, len(users))
-
-	for _, user := range users {
-		if user.Phone != "" {
-			ats = append(ats, "@"+user.Phone)
-		}
-		if token, has := user.ExtractToken(models.Dingtalk); has {
-			url := token
-			if !strings.HasPrefix(token, "https://") && !strings.HasPrefix(token, "http://") {
-				url = "https://oapi.dingtalk.com/robot/send?access_token=" + token
-			}
-			urls = append(urls, url)
-		}
-	}
-	return urls, ats
-}

alert/sender/email.go

@@ -1,215 +0,0 @@
-package sender
-
-import (
-	"crypto/tls"
-	"errors"
-	"html/template"
-	"time"
-
-	"github.com/ccfos/nightingale/v6/alert/aconf"
-	"github.com/ccfos/nightingale/v6/memsto"
-	"github.com/ccfos/nightingale/v6/models"
-
-	"github.com/toolkits/pkg/logger"
-
-	"gopkg.in/gomail.v2"
-)
-
-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 || len(ctx.Events) == 0 {
-		return
-	}
-	tos := extract(ctx.Users)
-	var subject string
-
-	if es.subjectTpl != nil {
-		subject = BuildTplMessage(models.Email, es.subjectTpl, []*models.AlertCurEvent{ctx.Events[0]})
-	} else {
-		subject = ctx.Events[0].RuleName
-	}
-	content := BuildTplMessage(models.Email, es.contentTpl, ctx.Events)
-	es.WriteEmail(subject, content, tos)
-
-	ctx.Stats.AlertNotifyTotal.WithLabelValues(models.Email).Add(float64(len(tos)))
-}
-
-func extract(users []*models.User) []string {
-	tos := make([]string, 0, len(users))
-	for _, u := range users {
-		if u.Email != "" {
-			tos = append(tos, u.Email)
-		}
-	}
-	return tos
-}
-
-func SendEmail(subject, content string, tos []string, stmp aconf.SMTPConfig) error {
-	conf := stmp
-
-	d := gomail.NewDialer(conf.Host, conf.Port, conf.User, conf.Pass)
-	if conf.InsecureSkipVerify {
-		d.TLSConfig = &tls.Config{InsecureSkipVerify: true}
-	}
-
-	m := gomail.NewMessage()
-
-	m.SetHeader("From", stmp.From)
-	m.SetHeader("To", tos...)
-	m.SetHeader("Subject", subject)
-	m.SetBody("text/html", content)
-
-	err := d.DialAndSend(m)
-	if err != nil {
-		return errors.New("email_sender: failed to send: " + err.Error())
-	}
-	return nil
-}
-
-func (es *EmailSender) WriteEmail(subject, content string, tos []string) {
-	m := gomail.NewMessage()
-
-	m.SetHeader("From", es.smtp.From)
-	m.SetHeader("To", tos...)
-	m.SetHeader("Subject", subject)
-	m.SetBody("text/html", content)
-
-	mailch <- m
-}
-
-func dialSmtp(d *gomail.Dialer) gomail.SendCloser {
-	for {
-		select {
-		case <-mailQuit:
-			// Note that Sendcloser is not obtained below,
-			// and the outgoing signal (with configuration changes) exits the current dial
-			return nil
-		default:
-			if s, err := d.Dial(); err != nil {
-				logger.Errorf("email_sender: failed to dial smtp: %s", err)
-			} else {
-				return s
-			}
-			time.Sleep(time.Second)
-		}
-	}
-}
-
-var mailQuit = make(chan struct{})
-
-func RestartEmailSender(smtp aconf.SMTPConfig) {
-	// Notify internal start exit
-	mailQuit <- struct{}{}
-	startEmailSender(smtp)
-}
-
-var smtpConfig aconf.SMTPConfig
-
-func InitEmailSender(ncc *memsto.NotifyConfigCacheType) {
-	mailch = make(chan *gomail.Message, 100000)
-	go updateSmtp(ncc)
-	smtpConfig = ncc.GetSMTP()
-	startEmailSender(smtpConfig)
-}
-
-func updateSmtp(ncc *memsto.NotifyConfigCacheType) {
-	for {
-		time.Sleep(1 * time.Minute)
-		smtp := ncc.GetSMTP()
-		if smtpConfig.Host != smtp.Host || smtpConfig.Batch != smtp.Batch || smtpConfig.From != smtp.From ||
-			smtpConfig.Pass != smtp.Pass || smtpConfig.User != smtp.User || smtpConfig.Port != smtp.Port ||
-			smtpConfig.InsecureSkipVerify != smtp.InsecureSkipVerify { //diff
-			smtpConfig = smtp
-			RestartEmailSender(smtp)
-		}
-	}
-}
-
-func startEmailSender(smtp aconf.SMTPConfig) {
-	conf := smtp
-	if conf.Host == "" || conf.Port == 0 {
-		logger.Warning("SMTP configurations invalid")
-		return
-	}
-	logger.Infof("start email sender... conf.Host:%+v,conf.Port:%+v", conf.Host, conf.Port)
-
-	d := gomail.NewDialer(conf.Host, conf.Port, conf.User, conf.Pass)
-	if conf.InsecureSkipVerify {
-		d.TLSConfig = &tls.Config{InsecureSkipVerify: true}
-	}
-
-	var s gomail.SendCloser
-	var open bool
-	var size int
-	for {
-		select {
-		case <-mailQuit:
-			return
-		case m, ok := <-mailch:
-			if !ok {
-				return
-			}
-
-			if !open {
-				s = dialSmtp(d)
-				if s == nil {
-					// Indicates that the dialing failed and exited the current goroutine directly,
-					// but put the Message back in the mailch
-					mailch <- m
-					return
-				}
-				open = true
-			}
-			if err := gomail.Send(s, m); err != nil {
-				logger.Errorf("email_sender: failed to send: %s", err)
-
-				// close and retry
-				if err := s.Close(); err != nil {
-					logger.Warningf("email_sender: failed to close smtp connection: %s", err)
-				}
-
-				s = dialSmtp(d)
-				if s == nil {
-					// Indicates that the dialing failed and exited the current goroutine directly,
-					// but put the Message back in the mailch
-					mailch <- m
-					return
-				}
-				open = true
-
-				if err := gomail.Send(s, m); err != nil {
-					logger.Errorf("email_sender: failed to retry send: %s", err)
-				}
-			} else {
-				logger.Infof("email_sender: result=succ subject=%v to=%v", m.GetHeader("Subject"), m.GetHeader("To"))
-			}
-
-			size++
-
-			if size >= conf.Batch {
-				if err := s.Close(); err != nil {
-					logger.Warningf("email_sender: failed to close smtp connection: %s", err)
-				}
-				open = false
-				size = 0
-			}
-
-		// Close the connection to the SMTP server if no email was sent in
-		// the last 30 seconds.
-		case <-time.After(30 * time.Second):
-			if open {
-				if err := s.Close(); err != nil {
-					logger.Warningf("email_sender: failed to close smtp connection: %s", err)
-				}
-				open = false
-			}
-		}
-	}
-}

alert/sender/feishu.go

@@ -1,101 +0,0 @@
-package sender
-
-import (
-	"fmt"
-	"html/template"
-	"strings"
-
-	"github.com/ccfos/nightingale/v6/models"
-)
-
-type feishuContent struct {
-	Text string `json:"text"`
-}
-
-type feishuAt struct {
-	AtMobiles []string `json:"atMobiles"`
-	IsAtAll   bool     `json:"isAtAll"`
-}
-
-type feishu struct {
-	Msgtype string        `json:"msg_type"`
-	Content feishuContent `json:"content"`
-	At      feishuAt      `json:"at"`
-}
-
-var (
-	_ CallBacker = (*FeishuSender)(nil)
-)
-
-type FeishuSender struct {
-	tpl *template.Template
-}
-
-func (fs *FeishuSender) CallBack(ctx CallBackContext) {
-	if len(ctx.Events) == 0 || len(ctx.CallBackURL) == 0 {
-		return
-	}
-
-	ats := ExtractAtsParams(ctx.CallBackURL)
-	message := BuildTplMessage(models.Feishu, fs.tpl, ctx.Events)
-
-	if len(ats) > 0 {
-		atTags := ""
-		for _, at := range ats {
-			atTags += fmt.Sprintf("<at user_id=\"%s\"></at> ", at)
-		}
-		message = atTags + message
-	}
-
-	body := feishu{
-		Msgtype: "text",
-		Content: feishuContent{
-			Text: message,
-		},
-	}
-
-	doSend(ctx.CallBackURL, body, models.Feishu, ctx.Stats)
-	ctx.Stats.AlertNotifyTotal.WithLabelValues("rule_callback").Inc()
-}
-
-func (fs *FeishuSender) Send(ctx MessageContext) {
-	if len(ctx.Users) == 0 || len(ctx.Events) == 0 {
-		return
-	}
-	urls, ats := fs.extract(ctx.Users)
-	message := BuildTplMessage(models.Feishu, fs.tpl, ctx.Events)
-	for _, url := range urls {
-		body := feishu{
-			Msgtype: "text",
-			Content: feishuContent{
-				Text: message,
-			},
-		}
-		if !strings.Contains(url, "noat=1") {
-			body.At = feishuAt{
-				AtMobiles: ats,
-				IsAtAll:   false,
-			}
-		}
-		doSend(url, body, models.Feishu, ctx.Stats)
-	}
-}
-
-func (fs *FeishuSender) extract(users []*models.User) ([]string, []string) {
-	urls := make([]string, 0, len(users))
-	ats := make([]string, 0, len(users))
-
-	for _, user := range users {
-		if user.Phone != "" {
-			ats = append(ats, user.Phone)
-		}
-		if token, has := user.ExtractToken(models.Feishu); has {
-			url := token
-			if !strings.HasPrefix(token, "https://") && !strings.HasPrefix(token, "http://") {
-				url = "https://open.feishu.cn/open-apis/bot/v2/hook/" + token
-			}
-			urls = append(urls, url)
-		}
-	}
-	return urls, ats
-}

alert/sender/feishucard.go

@@ -1,177 +0,0 @@
-package sender
-
-import (
-	"fmt"
-	"html/template"
-	"net/url"
-	"strings"
-
-	"github.com/ccfos/nightingale/v6/models"
-)
-
-type Conf struct {
-	WideScreenMode bool `json:"wide_screen_mode"`
-	EnableForward  bool `json:"enable_forward"`
-}
-
-type Te struct {
-	Content string `json:"content"`
-	Tag     string `json:"tag"`
-}
-
-type Element struct {
-	Tag      string    `json:"tag"`
-	Text     Te        `json:"text"`
-	Content  string    `json:"content"`
-	Elements []Element `json:"elements"`
-}
-
-type Titles struct {
-	Content string `json:"content"`
-	Tag     string `json:"tag"`
-}
-
-type Headers struct {
-	Title    Titles `json:"title"`
-	Template string `json:"template"`
-}
-
-type Cards struct {
-	Config   Conf      `json:"config"`
-	Elements []Element `json:"elements"`
-	Header   Headers   `json:"header"`
-}
-
-type feishuCard struct {
-	feishu
-	Card Cards `json:"card"`
-}
-
-type FeishuCardSender struct {
-	tpl *template.Template
-}
-
-const (
-	Recovered = "recovered"
-	Triggered = "triggered"
-)
-
-var (
-	body = feishuCard{
-		feishu: feishu{Msgtype: "interactive"},
-		Card: Cards{
-			Config: Conf{
-				WideScreenMode: true,
-				EnableForward:  true,
-			},
-			Header: Headers{
-				Title: Titles{
-					Tag: "plain_text",
-				},
-			},
-			Elements: []Element{
-				{
-					Tag: "div",
-					Text: Te{
-						Tag: "lark_md",
-					},
-				},
-				{
-					Tag: "hr",
-				},
-				{
-					Tag: "note",
-					Elements: []Element{
-						{
-							Tag: "lark_md",
-						},
-					},
-				},
-			},
-		},
-	}
-)
-
-func (fs *FeishuCardSender) CallBack(ctx CallBackContext) {
-	if len(ctx.Events) == 0 || len(ctx.CallBackURL) == 0 {
-		return
-	}
-
-	ats := ExtractAtsParams(ctx.CallBackURL)
-	message := BuildTplMessage(models.FeishuCard, fs.tpl, ctx.Events)
-
-	if len(ats) > 0 {
-		atTags := ""
-		for _, at := range ats {
-			if strings.Contains(at, "@") {
-				atTags += fmt.Sprintf("<at email=\"%s\" ></at>", at)
-			} else {
-				atTags += fmt.Sprintf("<at id=\"%s\" ></at>", at)
-			}
-		}
-		message = atTags + message
-	}
-
-	color := "red"
-	lowerUnicode := strings.ToLower(message)
-	if strings.Count(lowerUnicode, Recovered) > 0 && strings.Count(lowerUnicode, Triggered) > 0 {
-		color = "orange"
-	} else if strings.Count(lowerUnicode, Recovered) > 0 {
-		color = "green"
-	}
-
-	SendTitle := fmt.Sprintf("🔔 %s", ctx.Events[0].RuleName)
-	body.Card.Header.Title.Content = SendTitle
-	body.Card.Header.Template = color
-	body.Card.Elements[0].Text.Content = message
-	body.Card.Elements[2].Elements[0].Content = SendTitle
-
-	// This is to be compatible with the feishucard interface, if with query string parameters, the request will fail
-	// Remove query parameters from the URL,
-	parsedURL, err := url.Parse(ctx.CallBackURL)
-	if err != nil {
-		return
-	}
-	parsedURL.RawQuery = ""
-
-	doSend(parsedURL.String(), body, models.FeishuCard, ctx.Stats)
-}
-
-func (fs *FeishuCardSender) Send(ctx MessageContext) {
-	if len(ctx.Users) == 0 || len(ctx.Events) == 0 {
-		return
-	}
-	urls, _ := fs.extract(ctx.Users)
-	message := BuildTplMessage(models.FeishuCard, fs.tpl, ctx.Events)
-	color := "red"
-	lowerUnicode := strings.ToLower(message)
-	if strings.Count(lowerUnicode, Recovered) > 0 && strings.Count(lowerUnicode, Triggered) > 0 {
-		color = "orange"
-	} else if strings.Count(lowerUnicode, Recovered) > 0 {
-		color = "green"
-	}
-
-	SendTitle := fmt.Sprintf("🔔 %s", ctx.Events[0].RuleName)
-	body.Card.Header.Title.Content = SendTitle
-	body.Card.Header.Template = color
-	body.Card.Elements[0].Text.Content = message
-	body.Card.Elements[2].Elements[0].Content = SendTitle
-	for _, url := range urls {
-		doSend(url, body, models.FeishuCard, ctx.Stats)
-	}
-}
-
-func (fs *FeishuCardSender) extract(users []*models.User) ([]string, []string) {
-	urls := make([]string, 0, len(users))
-	ats := make([]string, 0)
-	for i := range users {
-		if token, has := users[i].ExtractToken(models.FeishuCard); has {
-			url := token
-			if !strings.HasPrefix(token, "https://") && !strings.HasPrefix(token, "http://") {
-				url = "https://open.feishu.cn/open-apis/bot/v2/hook/" + strings.TrimSpace(token)
-			}
-			urls = append(urls, url)
-		}
-	}
-	return urls, ats
-}

alert/sender/ibex.go

@@ -1,265 +0,0 @@
-// @Author: Ciusyan 6/5/24
-
-package sender
-
-import (
-	"encoding/json"
-	"fmt"
-	"strconv"
-	"strings"
-	"time"
-
-	"github.com/ccfos/nightingale/v6/memsto"
-	"github.com/ccfos/nightingale/v6/models"
-	"github.com/ccfos/nightingale/v6/pkg/ctx"
-	imodels "github.com/flashcatcloud/ibex/src/models"
-	"github.com/flashcatcloud/ibex/src/storage"
-
-	"github.com/toolkits/pkg/logger"
-)
-
-var (
-	_ CallBacker = (*IbexCallBacker)(nil)
-)
-
-type IbexCallBacker struct {
-	targetCache  *memsto.TargetCacheType
-	userCache    *memsto.UserCacheType
-	taskTplCache *memsto.TaskTplCache
-}
-
-func (c *IbexCallBacker) CallBack(ctx CallBackContext) {
-	if len(ctx.CallBackURL) == 0 || len(ctx.Events) == 0 {
-		return
-	}
-
-	event := ctx.Events[0]
-
-	if event.IsRecovered {
-		return
-	}
-
-	c.handleIbex(ctx.Ctx, ctx.CallBackURL, event)
-}
-
-func (c *IbexCallBacker) handleIbex(ctx *ctx.Context, url string, event *models.AlertCurEvent) {
-	if imodels.DB() == nil && ctx.IsCenter {
-		logger.Warning("event_callback_ibex: db is nil")
-		return
-	}
-
-	arr := strings.Split(url, "/")
-
-	var idstr string
-	var host string
-
-	if len(arr) > 1 {
-		idstr = arr[1]
-	}
-
-	if len(arr) > 2 {
-		host = arr[2]
-	}
-
-	id, err := strconv.ParseInt(idstr, 10, 64)
-	if err != nil {
-		logger.Errorf("event_callback_ibex: failed to parse url: %s", url)
-		return
-	}
-
-	if host == "" {
-		// 用户在callback url中没有传入host，就从event中解析
-		host = event.TargetIdent
-	}
-
-	if host == "" {
-		logger.Error("event_callback_ibex: failed to get host")
-		return
-	}
-
-	tpl := c.taskTplCache.Get(id)
-	if tpl == nil {
-		logger.Errorf("event_callback_ibex: no such tpl(%d)", id)
-		return
-	}
-
-	// check perm
-	// tpl.GroupId - host - account 三元组校验权限
-	can, err := canDoIbex(tpl.UpdateBy, tpl, host, c.targetCache, c.userCache)
-	if err != nil {
-		logger.Errorf("event_callback_ibex: check perm fail: %v", err)
-		return
-	}
-
-	if !can {
-		logger.Errorf("event_callback_ibex: user(%s) no permission", tpl.UpdateBy)
-		return
-	}
-
-	tagsMap := make(map[string]string)
-	for i := 0; i < len(event.TagsJSON); i++ {
-		pair := strings.TrimSpace(event.TagsJSON[i])
-		if pair == "" {
-			continue
-		}
-
-		arr := strings.Split(pair, "=")
-		if len(arr) != 2 {
-			continue
-		}
-
-		tagsMap[arr[0]] = arr[1]
-	}
-	// 附加告警级别  告警触发值标签
-	tagsMap["alert_severity"] = strconv.Itoa(event.Severity)
-	tagsMap["alert_trigger_value"] = event.TriggerValue
-
-	tags, err := json.Marshal(tagsMap)
-	if err != nil {
-		logger.Errorf("event_callback_ibex: failed to marshal tags to json: %v", tagsMap)
-		return
-	}
-
-	// call ibex
-	in := models.TaskForm{
-		Title:          tpl.Title + " FH: " + host,
-		Account:        tpl.Account,
-		Batch:          tpl.Batch,
-		Tolerance:      tpl.Tolerance,
-		Timeout:        tpl.Timeout,
-		Pause:          tpl.Pause,
-		Script:         tpl.Script,
-		Args:           tpl.Args,
-		Stdin:          string(tags),
-		Action:         "start",
-		Creator:        tpl.UpdateBy,
-		Hosts:          []string{host},
-		AlertTriggered: true,
-	}
-
-	id, err = TaskAdd(in, tpl.UpdateBy, ctx.IsCenter)
-	if err != nil {
-		logger.Errorf("event_callback_ibex: call ibex fail: %v", err)
-		return
-	}
-
-	// write db
-	record := models.TaskRecord{
-		Id:        id,
-		EventId:   event.Id,
-		GroupId:   tpl.GroupId,
-		Title:     in.Title,
-		Account:   in.Account,
-		Batch:     in.Batch,
-		Tolerance: in.Tolerance,
-		Timeout:   in.Timeout,
-		Pause:     in.Pause,
-		Script:    in.Script,
-		Args:      in.Args,
-		CreateAt:  time.Now().Unix(),
-		CreateBy:  in.Creator,
-	}
-
-	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, targetCache *memsto.TargetCacheType, userCache *memsto.UserCacheType) (bool, error) {
-	user := userCache.GetByUsername(username)
-	if user != nil && user.IsAdmin() {
-		return true, nil
-	}
-
-	target, has := targetCache.Get(host)
-	if !has {
-		return false, nil
-	}
-
-	return target.GroupId == tpl.GroupId, nil
-}
-
-func TaskAdd(f models.TaskForm, authUser string, isCenter bool) (int64, error) {
-	hosts := cleanHosts(f.Hosts)
-	if len(hosts) == 0 {
-		return 0, fmt.Errorf("arg(hosts) empty")
-	}
-
-	taskMeta := &imodels.TaskMeta{
-		Title:     f.Title,
-		Account:   f.Account,
-		Batch:     f.Batch,
-		Tolerance: f.Tolerance,
-		Timeout:   f.Timeout,
-		Pause:     f.Pause,
-		Script:    f.Script,
-		Args:      f.Args,
-		Stdin:     f.Stdin,
-		Creator:   f.Creator,
-	}
-
-	err := taskMeta.CleanFields()
-	if err != nil {
-		return 0, err
-	}
-
-	taskMeta.HandleFH(hosts[0])
-
-	// 任务类型分为"告警规则触发"和"n9e center用户下发"两种；
-	// 边缘机房"告警规则触发"的任务不需要规划，并且它可能是失联的，无法使用db资源，所以放入redis缓存中，直接下发给agentd执行
-	if !isCenter && f.AlertTriggered {
-		if err := taskMeta.Create(); err != nil {
-			// 当网络不连通时，生成唯一的id，防止边缘机房中不同任务的id相同；
-			// 方法是，redis自增id去防止同一个机房的不同n9e edge生成的id相同；
-			// 但没法防止不同边缘机房生成同样的id，所以，生成id的数据不会上报存入数据库，只用于闭环执行。
-			taskMeta.Id, err = storage.IdGet()
-			if err != nil {
-				return 0, err
-			}
-		}
-
-		taskHost := imodels.TaskHost{
-			Id:     taskMeta.Id,
-			Host:   hosts[0],
-			Status: "running",
-		}
-		if err = taskHost.Create(); err != nil {
-			logger.Warningf("task_add_fail: authUser=%s title=%s err=%s", authUser, taskMeta.Title, err.Error())
-		}
-
-		// 缓存任务元信息和待下发的任务
-		err = taskMeta.Cache(hosts[0])
-		if err != nil {
-			return 0, err
-		}
-
-	} else {
-		// 如果是中心机房，还是保持之前的逻辑
-		err = taskMeta.Save(hosts, f.Action)
-		if err != nil {
-			return 0, err
-		}
-	}
-
-	logger.Infof("task_add_succ: authUser=%s title=%s", authUser, taskMeta.Title)
-	return taskMeta.Id, nil
-}
-
-func cleanHosts(formHosts []string) []string {
-	cnt := len(formHosts)
-	arr := make([]string, 0, cnt)
-	for i := 0; i < cnt; i++ {
-		item := strings.TrimSpace(formHosts[i])
-		if item == "" {
-			continue
-		}
-
-		if strings.HasPrefix(item, "#") {
-			continue
-		}
-
-		arr = append(arr, item)
-	}
-
-	return arr
-}

alert/sender/lark.go

@@ -1,64 +0,0 @@
-package sender
-
-import (
-	"html/template"
-	"strings"
-
-	"github.com/ccfos/nightingale/v6/models"
-)
-
-var (
-	_ CallBacker = (*LarkSender)(nil)
-)
-
-type LarkSender struct {
-	tpl *template.Template
-}
-
-func (lk *LarkSender) CallBack(ctx CallBackContext) {
-	if len(ctx.Events) == 0 || len(ctx.CallBackURL) == 0 {
-		return
-	}
-
-	body := feishu{
-		Msgtype: "text",
-		Content: feishuContent{
-			Text: BuildTplMessage(models.Lark, lk.tpl, ctx.Events),
-		},
-	}
-
-	doSend(ctx.CallBackURL, body, models.Lark, ctx.Stats)
-	ctx.Stats.AlertNotifyTotal.WithLabelValues("rule_callback").Inc()
-}
-
-func (lk *LarkSender) Send(ctx MessageContext) {
-	if len(ctx.Users) == 0 || len(ctx.Events) == 0 {
-		return
-	}
-	urls := lk.extract(ctx.Users)
-	message := BuildTplMessage(models.Lark, lk.tpl, ctx.Events)
-	for _, url := range urls {
-		body := feishu{
-			Msgtype: "text",
-			Content: feishuContent{
-				Text: message,
-			},
-		}
-		doSend(url, body, models.Lark, ctx.Stats)
-	}
-}
-
-func (lk *LarkSender) extract(users []*models.User) []string {
-	urls := make([]string, 0, len(users))
-
-	for _, user := range users {
-		if token, has := user.ExtractToken(models.Lark); has {
-			url := token
-			if !strings.HasPrefix(token, "https://") && !strings.HasPrefix(token, "http://") {
-				url = "https://open.larksuite.com/open-apis/bot/v2/hook/" + token
-			}
-			urls = append(urls, url)
-		}
-	}
-	return urls
-}

alert/sender/larkcard.go

@@ -1,98 +0,0 @@
-package sender
-
-import (
-	"fmt"
-	"html/template"
-	"net/url"
-	"strings"
-
-	"github.com/ccfos/nightingale/v6/models"
-)
-
-type LarkCardSender struct {
-	tpl *template.Template
-}
-
-func (fs *LarkCardSender) CallBack(ctx CallBackContext) {
-	if len(ctx.Events) == 0 || len(ctx.CallBackURL) == 0 {
-		return
-	}
-
-	ats := ExtractAtsParams(ctx.CallBackURL)
-	message := BuildTplMessage(models.LarkCard, fs.tpl, ctx.Events)
-
-	if len(ats) > 0 {
-		atTags := ""
-		for _, at := range ats {
-			if strings.Contains(at, "@") {
-				atTags += fmt.Sprintf("<at email=\"%s\" ></at>", at)
-			} else {
-				atTags += fmt.Sprintf("<at id=\"%s\" ></at>", at)
-			}
-		}
-		message = atTags + message
-	}
-
-	color := "red"
-	lowerUnicode := strings.ToLower(message)
-	if strings.Count(lowerUnicode, Recovered) > 0 && strings.Count(lowerUnicode, Triggered) > 0 {
-		color = "orange"
-	} else if strings.Count(lowerUnicode, Recovered) > 0 {
-		color = "green"
-	}
-
-	SendTitle := fmt.Sprintf("🔔 %s", ctx.Events[0].RuleName)
-	body.Card.Header.Title.Content = SendTitle
-	body.Card.Header.Template = color
-	body.Card.Elements[0].Text.Content = message
-	body.Card.Elements[2].Elements[0].Content = SendTitle
-
-	// This is to be compatible with the Larkcard interface, if with query string parameters, the request will fail
-	// Remove query parameters from the URL,
-	parsedURL, err := url.Parse(ctx.CallBackURL)
-	if err != nil {
-		return
-	}
-	parsedURL.RawQuery = ""
-
-	doSend(parsedURL.String(), body, models.LarkCard, ctx.Stats)
-}
-
-func (fs *LarkCardSender) Send(ctx MessageContext) {
-	if len(ctx.Users) == 0 || len(ctx.Events) == 0 {
-		return
-	}
-	urls, _ := fs.extract(ctx.Users)
-	message := BuildTplMessage(models.LarkCard, fs.tpl, ctx.Events)
-	color := "red"
-	lowerUnicode := strings.ToLower(message)
-	if strings.Count(lowerUnicode, Recovered) > 0 && strings.Count(lowerUnicode, Triggered) > 0 {
-		color = "orange"
-	} else if strings.Count(lowerUnicode, Recovered) > 0 {
-		color = "green"
-	}
-
-	SendTitle := fmt.Sprintf("🔔 %s", ctx.Events[0].RuleName)
-	body.Card.Header.Title.Content = SendTitle
-	body.Card.Header.Template = color
-	body.Card.Elements[0].Text.Content = message
-	body.Card.Elements[2].Elements[0].Content = SendTitle
-	for _, url := range urls {
-		doSend(url, body, models.LarkCard, ctx.Stats)
-	}
-}
-
-func (fs *LarkCardSender) extract(users []*models.User) ([]string, []string) {
-	urls := make([]string, 0, len(users))
-	ats := make([]string, 0)
-	for i := range users {
-		if token, has := users[i].ExtractToken(models.Lark); has {
-			url := token
-			if !strings.HasPrefix(token, "https://") && !strings.HasPrefix(token, "http://") {
-				url = "https://open.larksuite.com/open-apis/bot/v2/hook/" + strings.TrimSpace(token)
-			}
-			urls = append(urls, url)
-		}
-	}
-	return urls, ats
-}

alert/sender/mm.go

@@ -1,117 +0,0 @@
-package sender
-
-import (
-	"html/template"
-	"net/url"
-	"strings"
-
-	"github.com/ccfos/nightingale/v6/alert/astats"
-	"github.com/ccfos/nightingale/v6/models"
-
-	"github.com/toolkits/pkg/logger"
-)
-
-type MatterMostMessage struct {
-	Text   string
-	Tokens []string
-	Stats  *astats.Stats
-}
-
-type mm struct {
-	Channel  string `json:"channel"`
-	Username string `json:"username"`
-	Text     string `json:"text"`
-}
-
-type MmSender struct {
-	tpl *template.Template
-}
-
-func (ms *MmSender) Send(ctx MessageContext) {
-	if len(ctx.Users) == 0 || len(ctx.Events) == 0 {
-		return
-	}
-
-	urls := ms.extract(ctx.Users)
-	if len(urls) == 0 {
-		return
-	}
-	message := BuildTplMessage(models.Mm, ms.tpl, ctx.Events)
-
-	SendMM(MatterMostMessage{
-		Text:   message,
-		Tokens: urls,
-		Stats:  ctx.Stats,
-	})
-}
-
-func (ms *MmSender) CallBack(ctx CallBackContext) {
-	if len(ctx.Events) == 0 || len(ctx.CallBackURL) == 0 {
-		return
-	}
-	message := BuildTplMessage(models.Mm, ms.tpl, ctx.Events)
-
-	SendMM(MatterMostMessage{
-		Text:   message,
-		Tokens: []string{ctx.CallBackURL},
-		Stats:  ctx.Stats,
-	})
-
-	ctx.Stats.AlertNotifyTotal.WithLabelValues("rule_callback").Inc()
-}
-
-func (ms *MmSender) extract(users []*models.User) []string {
-	tokens := make([]string, 0, len(users))
-	for _, user := range users {
-		if token, has := user.ExtractToken(models.Mm); has {
-			tokens = append(tokens, token)
-		}
-	}
-	return tokens
-}
-
-func SendMM(message MatterMostMessage) {
-	for i := 0; i < len(message.Tokens); i++ {
-		u, err := url.Parse(message.Tokens[i])
-		if err != nil {
-			logger.Errorf("mm_sender: failed to parse error=%v", err)
-			continue
-		}
-
-		v, err := url.ParseQuery(u.RawQuery)
-		if err != nil {
-			logger.Errorf("mm_sender: failed to parse query error=%v", err)
-		}
-
-		channels := v["channel"] // do not get
-		txt := ""
-		atuser := v["atuser"]
-		if len(atuser) != 0 {
-			txt = strings.Join(MapStrToStr(atuser, func(u string) string {
-				return "@" + u
-			}), ",") + "\n"
-		}
-		username := v.Get("username")
-		if err != nil {
-			logger.Errorf("mm_sender: failed to parse error=%v", err)
-		}
-		// simple concatenating
-		ur := u.Scheme + "://" + u.Host + u.Path
-		for _, channel := range channels {
-			body := mm{
-				Channel:  channel,
-				Username: username,
-				Text:     txt + message.Text,
-			}
-			doSend(ur, body, models.Mm, message.Stats)
-		}
-	}
-}
-
-func MapStrToStr(arr []string, fn func(s string) string) []string {
-	var newArray = []string{}
-	for _, it := range arr {
-		newArray = append(newArray, fn(it))
-	}
-	return newArray
-}

alert/sender/plugin.go

@@ -1,104 +0,0 @@
-package sender
-
-import (
-	"bytes"
-	"os"
-	"os/exec"
-	"time"
-
-	"github.com/ccfos/nightingale/v6/alert/astats"
-	"github.com/ccfos/nightingale/v6/models"
-
-	"github.com/toolkits/pkg/file"
-	"github.com/toolkits/pkg/logger"
-	"github.com/toolkits/pkg/sys"
-)
-
-func MayPluginNotify(noticeBytes []byte, notifyScript models.NotifyScript, stats *astats.Stats) {
-	if len(noticeBytes) == 0 {
-		return
-	}
-	alertingCallScript(noticeBytes, notifyScript, stats)
-}
-
-func alertingCallScript(stdinBytes []byte, notifyScript models.NotifyScript, stats *astats.Stats) {
-	// not enable or no notify.py? do nothing
-	config := notifyScript
-	if !config.Enable || config.Content == "" {
-		return
-	}
-
-	channel := "script"
-	stats.AlertNotifyTotal.WithLabelValues(channel).Inc()
-	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_script_notify_fail: read script file err: %v", err)
-				stats.AlertNotifyErrorTotal.WithLabelValues(channel).Inc()
-				return
-			}
-
-			if oldContent == config.Content {
-				rewrite = false
-			}
-		}
-
-		if rewrite {
-			_, err := file.WriteString(fpath, config.Content)
-			if err != nil {
-				logger.Errorf("event_script_notify_fail: write script file err: %v", err)
-				stats.AlertNotifyErrorTotal.WithLabelValues(channel).Inc()
-				return
-			}
-
-			err = os.Chmod(fpath, 0777)
-			if err != nil {
-				logger.Errorf("event_script_notify_fail: chmod script file err: %v", err)
-				stats.AlertNotifyErrorTotal.WithLabelValues(channel).Inc()
-				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_script_notify_fail: 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_script_notify_fail: timeout and killed process %s", fpath)
-		}
-
-		if err != nil {
-			logger.Errorf("event_script_notify_fail: kill process %s occur error %v", fpath, err)
-			stats.AlertNotifyErrorTotal.WithLabelValues(channel).Inc()
-		}
-		return
-	}
-
-	if err != nil {
-		logger.Errorf("event_script_notify_fail: exec script %s occur error: %v, output: %s", fpath, err, buf.String())
-		stats.AlertNotifyErrorTotal.WithLabelValues(channel).Inc()
-		return
-	}
-
-	logger.Infof("event_script_notify_ok: exec %s output: %s", fpath, buf.String())
-}

alert/sender/sender.go

@@ -1,81 +0,0 @@
-package sender
-
-import (
-	"bytes"
-	"html/template"
-
-	"github.com/ccfos/nightingale/v6/alert/aconf"
-	"github.com/ccfos/nightingale/v6/alert/astats"
-	"github.com/ccfos/nightingale/v6/memsto"
-	"github.com/ccfos/nightingale/v6/models"
-)
-
-type (
-	// Sender 发送消息通知的接口
-	Sender interface {
-		Send(ctx MessageContext)
-	}
-
-	// MessageContext 一个event所生成的告警通知的上下文
-	MessageContext struct {
-		Users  []*models.User
-		Rule   *models.AlertRule
-		Events []*models.AlertCurEvent
-		Stats  *astats.Stats
-	}
-)
-
-func NewSender(key string, tpls map[string]*template.Template, smtp ...aconf.SMTPConfig) Sender {
-	switch key {
-	case models.Dingtalk:
-		return &DingtalkSender{tpl: tpls[models.Dingtalk]}
-	case models.Wecom:
-		return &WecomSender{tpl: tpls[models.Wecom]}
-	case models.Feishu:
-		return &FeishuSender{tpl: tpls[models.Feishu]}
-	case models.FeishuCard:
-		return &FeishuCardSender{tpl: tpls[models.FeishuCard]}
-	case models.Email:
-		return &EmailSender{subjectTpl: tpls[models.EmailSubject], contentTpl: tpls[models.Email], smtp: smtp[0]}
-	case models.Mm:
-		return &MmSender{tpl: tpls[models.Mm]}
-	case models.Telegram:
-		return &TelegramSender{tpl: tpls[models.Telegram]}
-	case models.Lark:
-		return &LarkSender{tpl: tpls[models.Lark]}
-	case models.LarkCard:
-		return &LarkCardSender{tpl: tpls[models.LarkCard]}
-	}
-	return nil
-}
-
-func BuildMessageContext(rule *models.AlertRule, events []*models.AlertCurEvent, uids []int64, userCache *memsto.UserCacheType, stats *astats.Stats) MessageContext {
-	users := userCache.GetByUserIds(uids)
-	return MessageContext{
-		Rule:   rule,
-		Events: events,
-		Users:  users,
-		Stats:  stats,
-	}
-}
-
-type BuildTplMessageFunc func(channel string, tpl *template.Template, events []*models.AlertCurEvent) string
-
-var BuildTplMessage BuildTplMessageFunc = buildTplMessage
-
-func buildTplMessage(channel string, tpl *template.Template, events []*models.AlertCurEvent) string {
-	if tpl == nil {
-		return "tpl for current sender not found, please check configuration"
-	}
-
-	var content string
-	for _, event := range events {
-		var body bytes.Buffer
-		if err := tpl.Execute(&body, event); err != nil {
-			return err.Error()
-		}
-		content += body.String() + "\n\n"
-	}
-
-	return content
-}

alert/sender/telegram.go

@@ -1,97 +0,0 @@
-package sender
-
-import (
-	"html/template"
-	"strings"
-
-	"github.com/ccfos/nightingale/v6/alert/astats"
-	"github.com/ccfos/nightingale/v6/models"
-
-	"github.com/toolkits/pkg/logger"
-)
-
-type TelegramMessage struct {
-	Text   string
-	Tokens []string
-	Stats  *astats.Stats
-}
-
-type telegram struct {
-	ParseMode string `json:"parse_mode"`
-	Text      string `json:"text"`
-}
-
-var (
-	_ CallBacker = (*TelegramSender)(nil)
-)
-
-type TelegramSender struct {
-	tpl *template.Template
-}
-
-func (ts *TelegramSender) CallBack(ctx CallBackContext) {
-	if len(ctx.Events) == 0 || len(ctx.CallBackURL) == 0 {
-		return
-	}
-
-	message := BuildTplMessage(models.Telegram, ts.tpl, ctx.Events)
-	SendTelegram(TelegramMessage{
-		Text:   message,
-		Tokens: []string{ctx.CallBackURL},
-		Stats:  ctx.Stats,
-	})
-
-	ctx.Stats.AlertNotifyTotal.WithLabelValues("rule_callback").Inc()
-}
-
-func (ts *TelegramSender) Send(ctx MessageContext) {
-	if len(ctx.Users) == 0 || len(ctx.Events) == 0 {
-		return
-	}
-	tokens := ts.extract(ctx.Users)
-	message := BuildTplMessage(models.Telegram, ts.tpl, ctx.Events)
-
-	SendTelegram(TelegramMessage{
-		Text:   message,
-		Tokens: tokens,
-		Stats:  ctx.Stats,
-	})
-}
-
-func (ts *TelegramSender) extract(users []*models.User) []string {
-	tokens := make([]string, 0, len(users))
-	for _, user := range users {
-		if token, has := user.ExtractToken(models.Telegram); has {
-			tokens = append(tokens, token)
-		}
-	}
-	return tokens
-}
-
-func SendTelegram(message TelegramMessage) {
-	for i := 0; i < len(message.Tokens); i++ {
-		if !strings.Contains(message.Tokens[i], "/") && !strings.HasPrefix(message.Tokens[i], "https://") {
-			logger.Errorf("telegram_sender: result=fail invalid token=%s", message.Tokens[i])
-			continue
-		}
-		var url string
-		if strings.HasPrefix(message.Tokens[i], "https://") || strings.HasPrefix(message.Tokens[i], "http://") {
-			url = message.Tokens[i]
-		} else {
-			array := strings.Split(message.Tokens[i], "/")
-			if len(array) != 2 {
-				logger.Errorf("telegram_sender: result=fail invalid token=%s", message.Tokens[i])
-				continue
-			}
-			botToken := array[0]
-			chatId := array[1]
-			url = "https://api.telegram.org/bot" + botToken + "/sendMessage?chat_id=" + chatId
-		}
-		body := telegram{
-			ParseMode: "markdown",
-			Text:      message.Text,
-		}
-
-		doSend(url, body, models.Telegram, message.Stats)
-	}
-}

alert/sender/webhook.go

@@ -1,173 +0,0 @@
-package sender
-
-import (
-	"bytes"
-	"crypto/tls"
-	"encoding/json"
-	"io"
-	"net/http"
-	"sync"
-	"time"
-
-	"github.com/ccfos/nightingale/v6/alert/astats"
-	"github.com/ccfos/nightingale/v6/models"
-
-	"github.com/toolkits/pkg/logger"
-)
-
-func sendWebhook(webhook *models.Webhook, event interface{}, stats *astats.Stats) bool {
-	channel := "webhook"
-	if webhook.Type == models.RuleCallback {
-		channel = "callback"
-	}
-
-	conf := webhook
-	if conf.Url == "" || !conf.Enable {
-		return false
-	}
-	bs, err := json.Marshal(event)
-	if err != nil {
-		logger.Errorf("%s alertingWebhook failed to marshal event:%+v err:%v", channel, event, err)
-		return false
-	}
-
-	bf := bytes.NewBuffer(bs)
-
-	req, err := http.NewRequest("POST", conf.Url, bf)
-	if err != nil {
-		logger.Warningf("%s alertingWebhook failed to new reques event:%s err:%v", channel, string(bs), err)
-		return true
-	}
-
-	req.Header.Set("Content-Type", "application/json")
-	if conf.BasicAuthUser != "" && conf.BasicAuthPass != "" {
-		req.SetBasicAuth(conf.BasicAuthUser, conf.BasicAuthPass)
-	}
-
-	if len(conf.Headers) > 0 && len(conf.Headers)%2 == 0 {
-		for i := 0; i < len(conf.Headers); i += 2 {
-			if conf.Headers[i] == "host" || conf.Headers[i] == "Host" {
-				req.Host = conf.Headers[i+1]
-				continue
-			}
-			req.Header.Set(conf.Headers[i], conf.Headers[i+1])
-		}
-	}
-	insecureSkipVerify := false
-	if webhook != nil {
-		insecureSkipVerify = webhook.SkipVerify
-	}
-	client := http.Client{
-		Timeout: time.Duration(conf.Timeout) * time.Second,
-		Transport: &http.Transport{
-			TLSClientConfig: &tls.Config{InsecureSkipVerify: insecureSkipVerify},
-		},
-	}
-
-	stats.AlertNotifyTotal.WithLabelValues(channel).Inc()
-	var resp *http.Response
-	resp, err = client.Do(req)
-	if err != nil {
-		stats.AlertNotifyErrorTotal.WithLabelValues(channel).Inc()
-		logger.Errorf("event_%s_fail, event:%s, url: [%s], error: [%s]", channel, string(bs), conf.Url, err)
-		return true
-	}
-
-	var body []byte
-	if resp.Body != nil {
-		defer resp.Body.Close()
-		body, _ = io.ReadAll(resp.Body)
-	}
-
-	if resp.StatusCode == 429 {
-		logger.Errorf("event_%s_fail, url: %s, response code: %d, body: %s event:%s", channel, conf.Url, resp.StatusCode, string(body), string(bs))
-		return true
-	}
-
-	logger.Debugf("event_%s_succ, url: %s, response code: %d, body: %s event:%s", channel, conf.Url, resp.StatusCode, string(body), string(bs))
-	return false
-}
-
-func SingleSendWebhooks(webhooks []*models.Webhook, event *models.AlertCurEvent, stats *astats.Stats) {
-	for _, conf := range webhooks {
-		retryCount := 0
-		for retryCount < 3 {
-			needRetry := sendWebhook(conf, event, stats)
-			if !needRetry {
-				break
-			}
-			retryCount++
-			time.Sleep(time.Minute * 1 * time.Duration(retryCount))
-		}
-	}
-}
-
-func BatchSendWebhooks(webhooks []*models.Webhook, event *models.AlertCurEvent, stats *astats.Stats) {
-	for _, conf := range webhooks {
-		logger.Infof("push event:%+v to queue:%v", event, conf)
-		PushEvent(conf, event, stats)
-	}
-}
-
-var EventQueue = make(map[string]*WebhookQueue)
-var CallbackEventQueue = make(map[string]*WebhookQueue)
-var CallbackEventQueueLock sync.RWMutex
-var EventQueueLock sync.RWMutex
-
-const QueueMaxSize = 100000
-
-type WebhookQueue struct {
-	list    *SafeListLimited
-	closeCh chan struct{}
-}
-
-func PushEvent(webhook *models.Webhook, event *models.AlertCurEvent, stats *astats.Stats) {
-	EventQueueLock.RLock()
-	queue := EventQueue[webhook.Url]
-	EventQueueLock.RUnlock()
-
-	if queue == nil {
-		queue = &WebhookQueue{
-			list:    NewSafeListLimited(QueueMaxSize),
-			closeCh: make(chan struct{}),
-		}
-
-		EventQueueLock.Lock()
-		EventQueue[webhook.Url] = queue
-		EventQueueLock.Unlock()
-
-		StartConsumer(queue, webhook.Batch, webhook, stats)
-	}
-
-	succ := queue.list.PushFront(event)
-	if !succ {
-		stats.AlertNotifyErrorTotal.WithLabelValues("push_event_queue").Inc()
-		logger.Warningf("Write channel(%s) full, current channel size: %d event:%v", webhook.Url, queue.list.Len(), event)
-	}
-}
-
-func StartConsumer(queue *WebhookQueue, popSize int, webhook *models.Webhook, stats *astats.Stats) {
-	for {
-		select {
-		case <-queue.closeCh:
-			logger.Infof("event queue:%v closed", queue)
-			return
-		default:
-			events := queue.list.PopBack(popSize)
-			if len(events) == 0 {
-				time.Sleep(time.Millisecond * 400)
-				continue
-			}
-
-			retryCount := 0
-			for retryCount < webhook.RetryCount {
-				needRetry := sendWebhook(webhook, events, stats)
-				if !needRetry {
-					break
-				}
-				retryCount++
-				time.Sleep(time.Second * time.Duration(webhook.RetryInterval) * time.Duration(retryCount))
-			}
-		}
-	}
-}

alert/sender/webhook_queue.go

@@ -1,111 +0,0 @@
-package sender
-
-import (
-	"container/list"
-	"sync"
-
-	"github.com/ccfos/nightingale/v6/models"
-)
-
-type SafeList struct {
-	sync.RWMutex
-	L *list.List
-}
-
-func NewSafeList() *SafeList {
-	return &SafeList{L: list.New()}
-}
-
-func (sl *SafeList) PushFront(v interface{}) *list.Element {
-	sl.Lock()
-	e := sl.L.PushFront(v)
-	sl.Unlock()
-	return e
-}
-
-func (sl *SafeList) PushFrontBatch(vs []interface{}) {
-	sl.Lock()
-	for _, item := range vs {
-		sl.L.PushFront(item)
-	}
-	sl.Unlock()
-}
-
-func (sl *SafeList) PopBack(max int) []*models.AlertCurEvent {
-	sl.Lock()
-
-	count := sl.L.Len()
-	if count == 0 {
-		sl.Unlock()
-		return []*models.AlertCurEvent{}
-	}
-
-	if count > max {
-		count = max
-	}
-
-	items := make([]*models.AlertCurEvent, 0, count)
-	for i := 0; i < count; i++ {
-		item := sl.L.Remove(sl.L.Back())
-		sample, ok := item.(*models.AlertCurEvent)
-		if ok {
-			items = append(items, sample)
-		}
-	}
-
-	sl.Unlock()
-	return items
-}
-
-func (sl *SafeList) RemoveAll() {
-	sl.Lock()
-	sl.L.Init()
-	sl.Unlock()
-}
-
-func (sl *SafeList) Len() int {
-	sl.RLock()
-	size := sl.L.Len()
-	sl.RUnlock()
-	return size
-}
-
-// SafeList with Limited Size
-type SafeListLimited struct {
-	maxSize int
-	SL      *SafeList
-}
-
-func NewSafeListLimited(maxSize int) *SafeListLimited {
-	return &SafeListLimited{SL: NewSafeList(), maxSize: maxSize}
-}
-
-func (sll *SafeListLimited) PopBack(max int) []*models.AlertCurEvent {
-	return sll.SL.PopBack(max)
-}
-
-func (sll *SafeListLimited) PushFront(v interface{}) bool {
-	if sll.SL.Len() >= sll.maxSize {
-		return false
-	}
-
-	sll.SL.PushFront(v)
-	return true
-}
-
-func (sll *SafeListLimited) PushFrontBatch(vs []interface{}) bool {
-	if sll.SL.Len() >= sll.maxSize {
-		return false
-	}
-
-	sll.SL.PushFrontBatch(vs)
-	return true
-}
-
-func (sll *SafeListLimited) RemoveAll() {
-	sll.SL.RemoveAll()
-}
-
-func (sll *SafeListLimited) Len() int {
-	return sll.SL.Len()
-}

alert/sender/wecom.go

@@ -1,73 +0,0 @@
-package sender
-
-import (
-	"html/template"
-	"strings"
-
-	"github.com/ccfos/nightingale/v6/models"
-)
-
-type wecomMarkdown struct {
-	Content string `json:"content"`
-}
-
-type wecom struct {
-	Msgtype  string        `json:"msgtype"`
-	Markdown wecomMarkdown `json:"markdown"`
-}
-
-var (
-	_ CallBacker = (*WecomSender)(nil)
-)
-
-type WecomSender struct {
-	tpl *template.Template
-}
-
-func (ws *WecomSender) CallBack(ctx CallBackContext) {
-	if len(ctx.Events) == 0 || len(ctx.CallBackURL) == 0 {
-		return
-	}
-
-	message := BuildTplMessage(models.Wecom, ws.tpl, ctx.Events)
-	body := wecom{
-		Msgtype: "markdown",
-		Markdown: wecomMarkdown{
-			Content: message,
-		},
-	}
-
-	doSend(ctx.CallBackURL, body, models.Wecom, ctx.Stats)
-	ctx.Stats.AlertNotifyTotal.WithLabelValues("rule_callback").Inc()
-}
-
-func (ws *WecomSender) Send(ctx MessageContext) {
-	if len(ctx.Users) == 0 || len(ctx.Events) == 0 {
-		return
-	}
-	urls := ws.extract(ctx.Users)
-	message := BuildTplMessage(models.Wecom, ws.tpl, ctx.Events)
-	for _, url := range urls {
-		body := wecom{
-			Msgtype: "markdown",
-			Markdown: wecomMarkdown{
-				Content: message,
-			},
-		}
-		doSend(url, body, models.Wecom, ctx.Stats)
-	}
-}
-
-func (ws *WecomSender) extract(users []*models.User) []string {
-	urls := make([]string, 0, len(users))
-	for _, user := range users {
-		if token, has := user.ExtractToken(models.Wecom); has {
-			url := token
-			if !strings.HasPrefix(token, "https://") && !strings.HasPrefix(token, "http://") {
-				url = "https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=" + token
-			}
-			urls = append(urls, url)
-		}
-	}
-	return urls
-}

center/cconf/conf.go

@@ -1,40 +0,0 @@
-package cconf
-
-import "time"
-
-type Center struct {
-	Plugins                []Plugin
-	MetricsYamlFile        string
-	OpsYamlFile            string
-	BuiltinIntegrationsDir string
-	I18NHeaderKey          string
-	MetricDesc             MetricDescType
-	AnonymousAccess        AnonymousAccess
-	UseFileAssets          bool
-	FlashDuty              FlashDuty
-	EventHistoryGroupView  bool
-}
-
-type Plugin struct {
-	Id       int64  `json:"id"`
-	Category string `json:"category"`
-	Type     string `json:"plugin_type"`
-	TypeName string `json:"plugin_type_name"`
-}
-
-type FlashDuty struct {
-	Api     string
-	Headers map[string]string
-	Timeout time.Duration
-}
-
-type AnonymousAccess struct {
-	PromQuerier bool
-	AlertDetail bool
-}
-
-func (c *Center) PreCheck() {
-	if len(c.Plugins) == 0 {
-		c.Plugins = Plugins
-	}
-}

center/cconf/event_example.go

@@ -1,60 +0,0 @@
-package cconf
-
-const EVENT_EXAMPLE = `
-{
-    "id": 1000000,
-    "cate": "prometheus",
-    "datasource_id": 1,
-    "group_id": 1,
-    "group_name": "Default Busi Group",
-    "hash": "2cb966f9ba1cdc7af94c3796e855955a",
-    "rule_id": 23,
-    "rule_name": "测试告警",
-    "rule_note": "测试告警",
-    "rule_prod": "metric",
-    "rule_config": {
-        "queries": [
-            {
-                "key": "all_hosts",
-                "op": "==",
-                "values": []
-            }
-        ],
-        "triggers": [
-            {
-                "duration": 3,
-                "percent": 10,
-                "severity": 3,
-                "type": "pct_target_miss"
-            }
-        ]
-    },
-    "prom_for_duration": 60,
-    "prom_eval_interval": 30,
-    "callbacks": ["https://n9e.github.io"],
-    "notify_recovered": 1,
-    "notify_channels": ["dingtalk"],
-    "notify_groups": [],
-    "notify_groups_obj": null,
-    "target_ident": "host01",
-    "target_note": "机器备注",
-    "trigger_time": 1677229517,
-    "trigger_value": "2273533952",
-    "tags": [
-        "__name__=disk_free",
-        "dc=qcloud-dev",
-        "device=vda1",
-        "fstype=ext4",
-        "ident=tt-fc-dev00.nj"
-    ],
-    "is_recovered": false,
-    "notify_users_obj": null,
-    "last_eval_time": 1677229517,
-    "last_sent_time": 1677229517,
-    "notify_cur_number": 1,
-    "first_trigger_time": 1677229517,
-    "annotations": {
-        "summary": "测试告警"
-    }
-}
-`

center/cconf/metric.go

@@ -1,52 +0,0 @@
-package cconf
-
-import (
-	"path"
-
-	"github.com/toolkits/pkg/file"
-)
-
-// metricDesc , As load map happens before read map, there is no necessary to use concurrent map for metric desc store
-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 MetricDescType
-
-// GetMetricDesc , if metric is not registered, empty string will be returned
-func GetMetricDesc(lang, metric string) string {
-	var m map[string]string
-
-	switch lang {
-	case "en":
-		m = MetricDesc.En
-	default:
-		m = MetricDesc.Zh
-	}
-
-	if m != nil {
-		if desc, ok := m[metric]; ok {
-			return desc
-		}
-	}
-
-	if MetricDesc.CommonDesc != nil {
-		if desc, ok := MetricDesc.CommonDesc[metric]; ok {
-			return desc
-		}
-	}
-
-	return ""
-}
-func LoadMetricsYaml(configDir, metricsYamlFile string) error {
-	fp := metricsYamlFile
-	if fp == "" {
-		fp = path.Join(configDir, "metrics.yaml")
-	}
-	if !file.IsExist(fp) {
-		return nil
-	}
-	return file.ReadYaml(fp, &MetricDesc)
-}

center/cconf/ops.go

@@ -1,206 +0,0 @@
-package cconf
-
-import (
-	"fmt"
-	"path"
-
-	"github.com/toolkits/pkg/file"
-	"gopkg.in/yaml.v2"
-)
-
-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(configDir string, opsYamlFile string) error {
-	fp := opsYamlFile
-	if fp == "" {
-		fp = path.Join(configDir, "ops.yaml")
-	}
-	if !file.IsExist(fp) {
-		return nil
-	}
-
-	hash, _ := file.MD5(fp)
-	if hash == "2f91a9ed265cf2024e266dc1d538ee77" {
-		// ops.yaml 是老的默认文件，删除
-		file.Remove(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
-}
-
-func MergeOperationConf() error {
-	opsBuiltIn := Operation{}
-	err := yaml.Unmarshal([]byte(builtInOps), &opsBuiltIn)
-	if err != nil {
-		return fmt.Errorf("cannot parse builtInOps: %s", err.Error())
-	}
-	configOpsMap := make(map[string]struct{})
-	for _, op := range Operations.Ops {
-		configOpsMap[op.Name] = struct{}{}
-	}
-	//If the opBu.Name is not a constant in the target (Operations.Ops), add Ops from the built-in options
-	for _, opBu := range opsBuiltIn.Ops {
-		if _, has := configOpsMap[opBu.Name]; !has {
-			Operations.Ops = append(Operations.Ops, opBu)
-		}
-	}
-	return nil
-}
-
-const (
-	builtInOps = `
-ops:
-- name: dashboards
-  cname: 仪表盘
-  ops:
-    - "/dashboards"
-    - "/dashboards/add"
-    - "/dashboards/put"
-    - "/dashboards/del"
-    - "/embedded-dashboards/put"
-    - "/embedded-dashboards"
-    - "/public-dashboards"
-
-- name: alert
-  cname: 告警规则
-  ops:
-    - "/alert-rules"
-    - "/alert-rules/add"
-    - "/alert-rules/put"
-    - "/alert-rules/del"
-
-- name: alert-mutes
-  cname: 告警静默管理
-  ops:
-    - "/alert-mutes"
-    - "/alert-mutes/add"
-    - "/alert-mutes/put"
-    - "/alert-mutes/del"
-  
-- name: alert-subscribes
-  cname: 告警订阅管理
-  ops:
-    - "/alert-subscribes"
-    - "/alert-subscribes/add"
-    - "/alert-subscribes/put"
-    - "/alert-subscribes/del"
-
-- name: alert-events  
-  cname: 告警事件管理
-  ops:
-    - "/alert-cur-events"
-    - "/alert-cur-events/del"
-    - "/alert-his-events" 
-
-- name: recording-rules
-  cname: 记录规则管理
-  ops:
-    - "/recording-rules"
-    - "/recording-rules/add"
-    - "/recording-rules/put"
-    - "/recording-rules/del"
-
-- name: metric
-  cname: 时序指标
-  ops:
-  - "/metric/explorer"
-  - "/object/explorer"
-
-- name: log
-  cname: 日志分析
-  ops:
-  - "/log/explorer"
-  - "/log/index-patterns"
-
-- name: targets
-  cname: 基础设施
-  ops:
-    - "/targets"
-    - "/targets/add"
-    - "/targets/put"
-    - "/targets/del"
-    - "/targets/bind"
-
-- name: job
-  cname: 任务管理
-  ops:
-    - "/job-tpls"
-    - "/job-tpls/add"
-    - "/job-tpls/put"
-    - "/job-tpls/del"
-    - "/job-tasks"
-    - "/job-tasks/add"
-    - "/job-tasks/put"
-    - "/ibex-settings"
-
-- name: user
-  cname: 用户管理
-  ops:
-  - "/users"
-  - "/user-groups"
-  - "/user-groups/add"
-  - "/user-groups/put"
-  - "/user-groups/del"
-
-- name: permissions
-  cname: 权限管理
-  ops:
-  - "/permissions"
-
-- name: busi-groups
-  cname: 业务分组管理
-  ops:
-  - "/busi-groups"
-  - "/busi-groups/add"
-  - "/busi-groups/put"
-  - "/busi-groups/del"
-
-- name: builtin-metrics
-  cname: 指标视图
-  ops:
-    - "/metrics-built-in"
-    - "/builtin-metrics/add"
-    - "/builtin-metrics/put"
-    - "/builtin-metrics/del"
-
-- name: built-in-components
-  cname: 模版中心
-  ops:
-    - "/built-in-components"
-    - "/built-in-components/add"
-    - "/built-in-components/put"
-    - "/built-in-components/del"
-
-- name: system
-  cname: 系统信息
-  ops:
-  - "/help/variable-configs"
-  - "/help/version"
-  - "/help/servers"
-  - "/help/source"
-  - "/help/sso"
-  - "/help/notification-tpls"
-  - "/help/notification-settings"
-  - "/help/migrate"
-  - "/site-settings"
-`
-)

center/cconf/plugin.go

@@ -1,28 +0,0 @@
-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: "loki",
-		Type:     "loki",
-		TypeName: "Loki",
-	},
-	{
-		Id:       4,
-		Category: "timeseries",
-		Type:     "tdengine",
-		TypeName: "TDengine",
-	},
-}

center/cconf/rsa/rsa_conf.go

@@ -1,105 +0,0 @@
-package rsa
-
-import (
-	"os"
-
-	"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/secu"
-
-	"github.com/pkg/errors"
-	"github.com/toolkits/pkg/file"
-	"github.com/toolkits/pkg/logger"
-)
-
-func InitRSAConfig(ctx *ctx.Context, rsaConfig *httpx.RSAConfig) error {
-
-	// 1.Load RSA keys from Database
-	rsaPassWord, err := models.ConfigsGet(ctx, models.RSA_PASSWORD)
-	if err != nil {
-		return errors.WithMessagef(err, "cannot query config(%s)", models.RSA_PASSWORD)
-	}
-	privateKeyVal, err := models.ConfigsGet(ctx, models.RSA_PRIVATE_KEY)
-	if err != nil {
-		return errors.WithMessagef(err, "cannot query config(%s)", models.RSA_PRIVATE_KEY)
-	}
-	publicKeyVal, err := models.ConfigsGet(ctx, models.RSA_PUBLIC_KEY)
-	if err != nil {
-		return errors.WithMessagef(err, "cannot query config(%s)", models.RSA_PUBLIC_KEY)
-	}
-	if rsaPassWord != "" && privateKeyVal != "" && publicKeyVal != "" {
-		rsaConfig.RSAPassWord = rsaPassWord
-		rsaConfig.RSAPrivateKey = []byte(privateKeyVal)
-		rsaConfig.RSAPublicKey = []byte(publicKeyVal)
-		return nil
-	}
-
-	// 2.Read RSA configuration from file if exists
-	if file.IsExist(rsaConfig.RSAPrivateKeyPath) && file.IsExist(rsaConfig.RSAPublicKeyPath) {
-		//password already read from config
-		rsaConfig.RSAPrivateKey, rsaConfig.RSAPublicKey, err = readConfigFile(rsaConfig)
-		if err != nil {
-			return errors.WithMessage(err, "failed to read rsa config from file")
-		}
-		return nil
-	}
-	// 3.Generate RSA keys if not exist
-	rsaConfig.RSAPassWord, rsaConfig.RSAPrivateKey, rsaConfig.RSAPublicKey, err = initRSAKeyPairs(ctx, rsaConfig.RSAPassWord)
-	if err != nil {
-		return errors.WithMessage(err, "failed to generate rsa key pair")
-	}
-	return nil
-}
-
-func initRSAKeyPairs(ctx *ctx.Context, rsaPassWord string) (password string, privateByte, publicByte []byte, err error) {
-
-	// Generate RSA keys
-
-	// Generate RSA password
-	if rsaPassWord != "" {
-		logger.Debug("Using existing RSA password")
-		password = rsaPassWord
-		err = models.ConfigsSet(ctx, models.RSA_PASSWORD, password)
-		if err != nil {
-			err = errors.WithMessagef(err, "failed to set config(%s)", models.RSA_PASSWORD)
-			return
-		}
-	} else {
-		password, err = models.InitRSAPassWord(ctx)
-		if err != nil {
-			err = errors.WithMessage(err, "failed to generate rsa password")
-			return
-		}
-	}
-	privateByte, publicByte, err = secu.GenerateRsaKeyPair(password)
-	if err != nil {
-		err = errors.WithMessage(err, "failed to generate rsa key pair")
-		return
-	}
-	// Save generated RSA keys
-	err = models.ConfigsSet(ctx, models.RSA_PRIVATE_KEY, string(privateByte))
-	if err != nil {
-		err = errors.WithMessagef(err, "failed to set config(%s)", models.RSA_PRIVATE_KEY)
-		return
-	}
-	err = models.ConfigsSet(ctx, models.RSA_PUBLIC_KEY, string(publicByte))
-	if err != nil {
-		err = errors.WithMessagef(err, "failed to set config(%s)", models.RSA_PUBLIC_KEY)
-		return
-	}
-	return
-}
-
-func readConfigFile(rsaConfig *httpx.RSAConfig) (privateBuf, publicBuf []byte, err error) {
-	publicBuf, err = os.ReadFile(rsaConfig.RSAPublicKeyPath)
-	if err != nil {
-		err = errors.WithMessagef(err, "could not read RSAPublicKeyPath %q", rsaConfig.RSAPublicKeyPath)
-		return
-	}
-	privateBuf, err = os.ReadFile(rsaConfig.RSAPrivateKeyPath)
-	if err != nil {
-		err = errors.WithMessagef(err, "could not read RSAPrivateKeyPath %q", rsaConfig.RSAPrivateKeyPath)
-	}
-	return
-}

center/cconf/sql_tpl.go

@@ -1,15 +0,0 @@
-package cconf
-
-var TDengineSQLTpl = map[string]string{
-	"load5":                "SELECT _wstart as ts, last(load5) FROM $database.system WHERE host = '$server' and _ts >= $from and _ts <= $to interval($interval) fill(null)",
-	"process_total":        "SELECT _wstart as ts, last(total) FROM $database.processes WHERE host = '$server' and _ts >= $from and _ts <= $to interval($interval) fill(null)",
-	"thread_total":         "SELECT _wstart as ts, last(total) FROM $database.threads WHERE host = '$server' and _ts >= $from and _ts <= $to interval($interval) fill(null)",
-	"cpu_idle":             "SELECT _wstart as ts, last(usage_idle) * -1 + 100 FROM $database.cpu WHERE (host = '$server' and cpu = 'cpu-total') and _ts >= $from and _ts <= $to interval($interval) fill(null)",
-	"mem_used_percent":     "SELECT _wstart as ts, last(used_percent) FROM $database.mem WHERE (host = '$server') and _ts >= $from and _ts <= $to interval($interval) fill(null)",
-	"disk_used_percent":    "SELECT _wstart as ts, last(used_percent) FROM $database.disk WHERE (host = '$server' and path = '/') and _ts >= $from and _ts <= $to interval($interval) fill(null)",
-	"cpu_context_switches": "select ts, derivative(context_switches, 1s, 0) as context FROM (SELECT _wstart as ts, avg(context_switches) as context_switches FROM $database.kernel WHERE host = '$server' and _ts >= $from and _ts <= $to interval($interval) )",
-	"tcp":                  "SELECT _wstart as ts, avg(tcp_close) as CLOSED, avg(tcp_close_wait) as CLOSE_WAIT, avg(tcp_closing) as CLOSING, avg(tcp_established) as ESTABLISHED, avg(tcp_fin_wait1) as FIN_WAIT1, avg(tcp_fin_wait2) as FIN_WAIT2, avg(tcp_last_ack) as LAST_ACK, avg(tcp_syn_recv) as SYN_RECV, avg(tcp_syn_sent) as SYN_SENT, avg(tcp_time_wait) as TIME_WAIT FROM $database.netstat WHERE host = '$server' and _ts >= $from and _ts <= $to interval($interval)",
-	"net_bytes_recv":       "SELECT _wstart as ts, derivative(bytes_recv,1s, 1) as bytes_in FROM $database.net WHERE host = '$server' and interface = '$netif' and _ts >= $from and _ts <= $to group by tbname",
-	"net_bytes_sent":       "SELECT _wstart as ts, derivative(bytes_sent,1s, 1) as bytes_out FROM $database.net WHERE host = '$server' and interface = '$netif' and _ts >= $from and _ts <= $to group by tbname",
-	"disk_total":           "SELECT _wstart as ts, avg(total) AS total, avg(used) as used FROM $database.disk WHERE   path = '$mountpoint' and _ts >= $from and _ts <= $to  interval($interval) group by host",
-}

center/center.go

@@ -1,132 +0,0 @@
-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"
-	alertrt "github.com/ccfos/nightingale/v6/alert/router"
-	"github.com/ccfos/nightingale/v6/center/cconf"
-	"github.com/ccfos/nightingale/v6/center/cconf/rsa"
-	"github.com/ccfos/nightingale/v6/center/cstats"
-	"github.com/ccfos/nightingale/v6/center/integration"
-	"github.com/ccfos/nightingale/v6/center/metas"
-	centerrt "github.com/ccfos/nightingale/v6/center/router"
-	"github.com/ccfos/nightingale/v6/center/sso"
-	"github.com/ccfos/nightingale/v6/conf"
-	"github.com/ccfos/nightingale/v6/dumper"
-	"github.com/ccfos/nightingale/v6/memsto"
-	"github.com/ccfos/nightingale/v6/models"
-	"github.com/ccfos/nightingale/v6/models/migrate"
-	"github.com/ccfos/nightingale/v6/pkg/ctx"
-	"github.com/ccfos/nightingale/v6/pkg/flashduty"
-	"github.com/ccfos/nightingale/v6/pkg/httpx"
-	"github.com/ccfos/nightingale/v6/pkg/i18nx"
-	"github.com/ccfos/nightingale/v6/pkg/logx"
-	"github.com/ccfos/nightingale/v6/pkg/version"
-	"github.com/ccfos/nightingale/v6/prom"
-	"github.com/ccfos/nightingale/v6/pushgw/idents"
-	pushgwrt "github.com/ccfos/nightingale/v6/pushgw/router"
-	"github.com/ccfos/nightingale/v6/pushgw/writer"
-	"github.com/ccfos/nightingale/v6/storage"
-	"github.com/ccfos/nightingale/v6/tdengine"
-
-	"github.com/flashcatcloud/ibex/src/cmd/ibex"
-)
-
-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(configDir, config.Center.MetricsYamlFile)
-	cconf.LoadOpsYaml(configDir, config.Center.OpsYamlFile)
-
-	cconf.MergeOperationConf()
-
-	logxClean, err := logx.Init(config.Log)
-	if err != nil {
-		return nil, err
-	}
-
-	i18nx.Init(configDir)
-	cstats.Init()
-	flashduty.Init(config.Center.FlashDuty)
-
-	db, err := storage.New(config.DB)
-	if err != nil {
-		return nil, err
-	}
-	ctx := ctx.NewContext(context.Background(), db, true)
-	migrate.Migrate(db)
-	models.InitRoot(ctx)
-
-	config.HTTP.JWTAuth.SigningKey = models.InitJWTSigningKey(ctx)
-
-	err = rsa.InitRSAConfig(ctx, &config.HTTP.RSA)
-	if err != nil {
-		return nil, err
-	}
-
-	integration.Init(ctx, config.Center.BuiltinIntegrationsDir)
-	var redis storage.Redis
-	redis, err = storage.NewRedis(config.Redis)
-	if err != nil {
-		return nil, err
-	}
-
-	metas := metas.New(redis)
-	idents := idents.New(ctx, redis)
-
-	syncStats := memsto.NewSyncStats()
-	alertStats := astats.NewSyncStats()
-
-	configCache := memsto.NewConfigCache(ctx, syncStats, config.HTTP.RSA.RSAPrivateKey, config.HTTP.RSA.RSAPassWord)
-	busiGroupCache := memsto.NewBusiGroupCache(ctx, syncStats)
-	targetCache := memsto.NewTargetCache(ctx, syncStats, redis)
-	dsCache := memsto.NewDatasourceCache(ctx, syncStats)
-	alertMuteCache := memsto.NewAlertMuteCache(ctx, syncStats)
-	alertRuleCache := memsto.NewAlertRuleCache(ctx, syncStats)
-	notifyConfigCache := memsto.NewNotifyConfigCache(ctx, configCache)
-	userCache := memsto.NewUserCache(ctx, syncStats)
-	userGroupCache := memsto.NewUserGroupCache(ctx, syncStats)
-	taskTplCache := memsto.NewTaskTplCache(ctx)
-
-	sso := sso.Init(config.Center, ctx, configCache)
-	promClients := prom.NewPromClient(ctx)
-	tdengineClients := tdengine.NewTdengineClient(ctx, config.Alert.Heartbeat)
-
-	externalProcessors := process.NewExternalProcessors()
-	alert.Start(config.Alert, config.Pushgw, syncStats, alertStats, externalProcessors, targetCache, busiGroupCache, alertMuteCache, alertRuleCache, notifyConfigCache, taskTplCache, dsCache, ctx, promClients, tdengineClients, userCache, userGroupCache)
-
-	writers := writer.NewWriters(config.Pushgw)
-
-	go version.GetGithubVersion()
-
-	alertrtRouter := alertrt.New(config.HTTP, config.Alert, alertMuteCache, targetCache, busiGroupCache, alertStats, ctx, externalProcessors)
-	centerRouter := centerrt.New(config.HTTP, config.Center, config.Alert, config.Ibex, cconf.Operations, dsCache, notifyConfigCache, promClients, tdengineClients,
-		redis, sso, ctx, metas, idents, targetCache, userCache, userGroupCache)
-	pushgwRouter := pushgwrt.New(config.HTTP, config.Pushgw, config.Alert, targetCache, busiGroupCache, idents, metas, writers, ctx)
-
-	r := httpx.GinEngine(config.Global.RunMode, config.HTTP)
-
-	centerRouter.Config(r)
-	alertrtRouter.Config(r)
-	pushgwRouter.Config(r)
-	dumper.ConfigRouter(r)
-
-	if config.Ibex.Enable {
-		migrate.MigrateIbexTables(db)
-		ibex.ServerStart(true, db, redis, config.HTTP.APIForService.BasicAuth, config.Alert.Heartbeat, &config.CenterApi, r, centerRouter, config.Ibex, config.HTTP.Port)
-	}
-
-	httpClean := httpx.Init(config.HTTP, r)
-
-	return func() {
-		logxClean()
-		httpClean()
-	}, nil
-}

center/integration/init.go

@@ -1,365 +0,0 @@
-package integration
-
-import (
-	"encoding/json"
-	"path"
-	"strings"
-	"time"
-
-	"github.com/ccfos/nightingale/v6/models"
-	"github.com/ccfos/nightingale/v6/pkg/ctx"
-	"github.com/toolkits/pkg/file"
-	"github.com/toolkits/pkg/logger"
-	"github.com/toolkits/pkg/runner"
-)
-
-const SYSTEM = "system"
-
-func Init(ctx *ctx.Context, builtinIntegrationsDir string) {
-	fp := builtinIntegrationsDir
-	if fp == "" {
-		fp = path.Join(runner.Cwd, "integrations")
-	}
-
-	// var fileList []string
-	dirList, err := file.DirsUnder(fp)
-	if err != nil {
-		logger.Warning("read builtin component dir fail ", err)
-		return
-	}
-
-	for _, dir := range dirList {
-		// components icon
-		componentDir := fp + "/" + dir
-		component := models.BuiltinComponent{
-			Ident: dir,
-		}
-
-		// get logo name
-		// /api/n9e/integrations/icon/AliYun/aliyun.png
-		files, err := file.FilesUnder(componentDir + "/icon")
-		if err == nil && len(files) > 0 {
-			component.Logo = "/api/n9e/integrations/icon/" + component.Ident + "/" + files[0]
-		} else if err != nil {
-			logger.Warningf("read builtin component icon dir fail %s %v", component.Ident, err)
-		}
-
-		// get description
-		files, err = file.FilesUnder(componentDir + "/markdown")
-		if err == nil && len(files) > 0 {
-			var readmeFile string
-			for _, file := range files {
-				if strings.HasSuffix(strings.ToLower(file), "md") {
-					readmeFile = componentDir + "/markdown/" + file
-					break
-				}
-			}
-			if readmeFile != "" {
-				component.Readme, _ = file.ReadString(readmeFile)
-			}
-		} else if err != nil {
-			logger.Warningf("read builtin component markdown dir fail %s %v", component.Ident, err)
-		}
-
-		exists, _ := models.BuiltinComponentExists(ctx, &component)
-		if !exists {
-			err = component.Add(ctx, SYSTEM)
-			if err != nil {
-				logger.Warning("add builtin component fail ", component, err)
-				continue
-			}
-		} else {
-			old, err := models.BuiltinComponentGet(ctx, "ident = ?", component.Ident)
-			if err != nil {
-				logger.Warning("get builtin component fail ", component, err)
-				continue
-			}
-
-			if old == nil {
-				logger.Warning("get builtin component nil ", component)
-				continue
-			}
-
-			if old.UpdatedBy == SYSTEM {
-				now := time.Now().Unix()
-				old.CreatedAt = now
-				old.UpdatedAt = now
-				old.Readme = component.Readme
-				old.UpdatedBy = SYSTEM
-
-				err = models.DB(ctx).Model(old).Select("*").Updates(old).Error
-				if err != nil {
-					logger.Warning("update builtin component fail ", old, err)
-				}
-			}
-		}
-
-		// delete uuid is emtpy
-		err = models.DB(ctx).Exec("delete from builtin_payloads where uuid = 0 and type != 'collect' and (updated_by = 'system' or updated_by = '')").Error
-		if err != nil {
-			logger.Warning("delete builtin payloads fail ", err)
-		}
-
-		// delete builtin metrics uuid is emtpy
-		err = models.DB(ctx).Exec("delete from builtin_metrics where uuid = 0 and (updated_by = 'system' or updated_by = '')").Error
-		if err != nil {
-			logger.Warning("delete builtin metrics fail ", err)
-		}
-
-		// alerts
-		files, err = file.FilesUnder(componentDir + "/alerts")
-		if err == nil && len(files) > 0 {
-			for _, f := range files {
-				fp := componentDir + "/alerts/" + f
-				bs, err := file.ReadBytes(fp)
-				if err != nil {
-					logger.Warning("read builtin component alerts file fail ", f, err)
-					continue
-				}
-
-				alerts := []models.AlertRule{}
-				err = json.Unmarshal(bs, &alerts)
-				if err != nil {
-					logger.Warning("parse builtin component alerts file fail ", f, err)
-					continue
-				}
-
-				newAlerts := []models.AlertRule{}
-				writeAlertFileFlag := false
-				for _, alert := range alerts {
-					if alert.UUID == 0 {
-						writeAlertFileFlag = true
-						alert.UUID = time.Now().UnixNano()
-					}
-
-					newAlerts = append(newAlerts, alert)
-					content, err := json.Marshal(alert)
-					if err != nil {
-						logger.Warning("marshal builtin alert fail ", alert, err)
-						continue
-					}
-
-					cate := strings.Replace(f, ".json", "", -1)
-					builtinAlert := models.BuiltinPayload{
-						Component: component.Ident,
-						Type:      "alert",
-						Cate:      cate,
-						Name:      alert.Name,
-						Tags:      alert.AppendTags,
-						Content:   string(content),
-						UUID:      alert.UUID,
-					}
-
-					old, err := models.BuiltinPayloadGet(ctx, "uuid = ?", alert.UUID)
-					if err != nil {
-						logger.Warning("get builtin alert fail ", builtinAlert, err)
-						continue
-					}
-
-					if old == nil {
-						err := builtinAlert.Add(ctx, SYSTEM)
-						if err != nil {
-							logger.Warning("add builtin alert fail ", builtinAlert, err)
-						}
-						continue
-					}
-
-					if old.UpdatedBy == SYSTEM {
-						old.Content = string(content)
-						old.Name = alert.Name
-						old.Tags = alert.AppendTags
-						err = models.DB(ctx).Model(old).Select("*").Updates(old).Error
-						if err != nil {
-							logger.Warningf("update builtin alert:%+v fail %v", builtinAlert, err)
-						}
-					}
-				}
-
-				if writeAlertFileFlag {
-					bs, err = json.MarshalIndent(newAlerts, "", "    ")
-					if err != nil {
-						logger.Warning("marshal builtin alerts fail ", newAlerts, err)
-						continue
-					}
-
-					_, err = file.WriteBytes(fp, bs)
-					if err != nil {
-						logger.Warning("write builtin alerts file fail ", f, err)
-					}
-				}
-
-			}
-		}
-
-		// dashboards
-		files, err = file.FilesUnder(componentDir + "/dashboards")
-		if err == nil && len(files) > 0 {
-			for _, f := range files {
-				fp := componentDir + "/dashboards/" + f
-				bs, err := file.ReadBytes(fp)
-				if err != nil {
-					logger.Warning("read builtin component dashboards file fail ", f, err)
-					continue
-				}
-
-				dashboard := BuiltinBoard{}
-				err = json.Unmarshal(bs, &dashboard)
-				if err != nil {
-					logger.Warning("parse builtin component dashboards file fail ", f, err)
-					continue
-				}
-
-				if dashboard.UUID == 0 {
-					dashboard.UUID = time.Now().UnixNano()
-					// 补全文件中的 uuid
-					bs, err = json.MarshalIndent(dashboard, "", "    ")
-					if err != nil {
-						logger.Warning("marshal builtin dashboard fail ", dashboard, err)
-						continue
-					}
-
-					_, err = file.WriteBytes(fp, bs)
-					if err != nil {
-						logger.Warning("write builtin dashboard file fail ", f, err)
-					}
-				}
-
-				content, err := json.Marshal(dashboard)
-				if err != nil {
-					logger.Warning("marshal builtin dashboard fail ", dashboard, err)
-					continue
-				}
-
-				builtinDashboard := models.BuiltinPayload{
-					Component: component.Ident,
-					Type:      "dashboard",
-					Cate:      "",
-					Name:      dashboard.Name,
-					Tags:      dashboard.Tags,
-					Content:   string(content),
-					UUID:      dashboard.UUID,
-				}
-
-				old, err := models.BuiltinPayloadGet(ctx, "uuid = ?", dashboard.UUID)
-				if err != nil {
-					logger.Warning("get builtin alert fail ", builtinDashboard, err)
-					continue
-				}
-
-				if old == nil {
-					err := builtinDashboard.Add(ctx, SYSTEM)
-					if err != nil {
-						logger.Warning("add builtin alert fail ", builtinDashboard, err)
-					}
-					continue
-				}
-
-				if old.UpdatedBy == SYSTEM {
-					old.Content = string(content)
-					old.Name = dashboard.Name
-					old.Tags = dashboard.Tags
-					err = models.DB(ctx).Model(old).Select("*").Updates(old).Error
-					if err != nil {
-						logger.Warningf("update builtin alert:%+v fail %v", builtinDashboard, err)
-					}
-				}
-			}
-		} else if err != nil {
-			logger.Warningf("read builtin component dash dir fail %s %v", component.Ident, err)
-		}
-
-		// metrics
-		files, err = file.FilesUnder(componentDir + "/metrics")
-		if err == nil && len(files) > 0 {
-			for _, f := range files {
-				fp := componentDir + "/metrics/" + f
-				bs, err := file.ReadBytes(fp)
-				if err != nil {
-					logger.Warning("read builtin component metrics file fail", f, err)
-					continue
-				}
-
-				metrics := []models.BuiltinMetric{}
-				newMetrics := []models.BuiltinMetric{}
-				err = json.Unmarshal(bs, &metrics)
-				if err != nil {
-					logger.Warning("parse builtin component metrics file fail", f, err)
-					continue
-				}
-
-				writeMetricFileFlag := false
-				for _, metric := range metrics {
-					if metric.UUID == 0 {
-						writeMetricFileFlag = true
-						metric.UUID = time.Now().UnixNano()
-					}
-					newMetrics = append(newMetrics, metric)
-
-					old, err := models.BuiltinMetricGet(ctx, "uuid = ?", metric.UUID)
-					if err != nil {
-						logger.Warning("get builtin metrics fail ", metric, err)
-						continue
-					}
-
-					if old == nil {
-						err := metric.Add(ctx, SYSTEM)
-						if err != nil {
-							logger.Warning("add builtin metrics fail ", metric, err)
-						}
-						continue
-					}
-
-					if old.UpdatedBy == SYSTEM {
-						old.Collector = metric.Collector
-						old.Typ = metric.Typ
-						old.Name = metric.Name
-						old.Unit = metric.Unit
-						old.Note = metric.Note
-						old.Lang = metric.Lang
-						old.Expression = metric.Expression
-
-						err = models.DB(ctx).Model(old).Select("*").Updates(old).Error
-						if err != nil {
-							logger.Warningf("update builtin metric:%+v fail %v", metric, err)
-						}
-					}
-				}
-
-				if writeMetricFileFlag {
-					bs, err = json.MarshalIndent(newMetrics, "", "    ")
-					if err != nil {
-						logger.Warning("marshal builtin metrics fail ", newMetrics, err)
-						continue
-					}
-
-					_, err = file.WriteBytes(fp, bs)
-					if err != nil {
-						logger.Warning("write builtin metrics file fail ", f, err)
-					}
-				}
-
-			}
-		} else if err != nil {
-			logger.Warningf("read builtin component metrics dir fail %s %v", component.Ident, err)
-		}
-	}
-}
-
-type BuiltinBoard struct {
-	Id         int64       `json:"id" gorm:"primaryKey"`
-	GroupId    int64       `json:"group_id"`
-	Name       string      `json:"name"`
-	Ident      string      `json:"ident"`
-	Tags       string      `json:"tags"`
-	CreateAt   int64       `json:"create_at"`
-	CreateBy   string      `json:"create_by"`
-	UpdateAt   int64       `json:"update_at"`
-	UpdateBy   string      `json:"update_by"`
-	Configs    interface{} `json:"configs" gorm:"-"`
-	Public     int         `json:"public"`      // 0: false, 1: true
-	PublicCate int         `json:"public_cate"` // 0: anonymous, 1: login, 2: busi
-	Bgids      []int64     `json:"bgids" gorm:"-"`
-	BuiltIn    int         `json:"built_in"` // 0: false, 1: true
-	Hide       int         `json:"hide"`     // 0: false, 1: true
-	UUID       int64       `json:"uuid"`
-}

center/metas/metas.go

@@ -1,131 +0,0 @@
-package metas
-
-import (
-	"context"
-	"encoding/json"
-	"sync"
-	"time"
-
-	"github.com/ccfos/nightingale/v6/models"
-	"github.com/ccfos/nightingale/v6/storage"
-
-	"github.com/toolkits/pkg/logger"
-)
-
-type Set struct {
-	sync.RWMutex
-	items map[string]models.HostMeta
-	redis storage.Redis
-}
-
-func New(redis storage.Redis) *Set {
-	set := &Set{
-		items: make(map[string]models.HostMeta),
-		redis: redis,
-	}
-
-	set.Init()
-	return set
-}
-
-func (s *Set) Init() {
-	go s.LoopPersist()
-}
-
-func (s *Set) MSet(items map[string]models.HostMeta) {
-	s.Lock()
-	defer s.Unlock()
-	for ident, meta := range items {
-		s.items[ident] = meta
-	}
-}
-
-func (s *Set) Set(ident string, meta models.HostMeta) {
-	s.Lock()
-	defer s.Unlock()
-	s.items[ident] = meta
-}
-
-func (s *Set) LoopPersist() {
-	for {
-		time.Sleep(time.Second)
-		s.persist()
-	}
-}
-
-func (s *Set) persist() {
-	var items map[string]models.HostMeta
-
-	s.Lock()
-	if len(s.items) == 0 {
-		s.Unlock()
-		return
-	}
-
-	items = s.items
-	s.items = make(map[string]models.HostMeta)
-	s.Unlock()
-
-	s.updateMeta(items)
-}
-
-func (s *Set) updateMeta(items map[string]models.HostMeta) {
-	m := make(map[string]models.HostMeta, 100)
-	num := 0
-
-	for _, meta := range items {
-		m[meta.Hostname] = meta
-		num++
-		if num == 100 {
-			if err := s.updateTargets(m); err != nil {
-				logger.Errorf("failed to update targets: %v", err)
-			}
-			m = make(map[string]models.HostMeta, 100)
-			num = 0
-		}
-	}
-
-	if err := s.updateTargets(m); err != nil {
-		logger.Errorf("failed to update targets: %v", err)
-	}
-}
-
-func (s *Set) updateTargets(m map[string]models.HostMeta) error {
-	if s.redis == nil {
-		logger.Warningf("redis is nil")
-		return nil
-	}
-
-	count := int64(len(m))
-	if count == 0 {
-		return nil
-	}
-
-	newMap := make(map[string]interface{}, count)
-	extendMap := make(map[string]interface{})
-	for ident, meta := range m {
-		if meta.ExtendInfo != nil {
-			extendMeta := meta.ExtendInfo
-			meta.ExtendInfo = make(map[string]interface{})
-			extendMetaStr, err := json.Marshal(extendMeta)
-			if err != nil {
-				return err
-			}
-			extendMap[models.WrapExtendIdent(ident)] = extendMetaStr
-		}
-		newMap[models.WrapIdent(ident)] = meta
-	}
-	err := storage.MSet(context.Background(), s.redis, newMap)
-	if err != nil {
-		return err
-	}
-
-	if len(extendMap) > 0 {
-		err = storage.MSet(context.Background(), s.redis, extendMap)
-		if err != nil {
-			return err
-		}
-	}
-
-	return err
-}

center/router/router.go

@@ -1,595 +0,0 @@
-package router
-
-import (
-	"fmt"
-	"net/http"
-	"path"
-	"runtime"
-	"strings"
-	"time"
-
-	"github.com/ccfos/nightingale/v6/alert/aconf"
-	"github.com/ccfos/nightingale/v6/center/cconf"
-	"github.com/ccfos/nightingale/v6/center/cstats"
-	"github.com/ccfos/nightingale/v6/center/metas"
-	"github.com/ccfos/nightingale/v6/center/sso"
-	"github.com/ccfos/nightingale/v6/conf"
-	_ "github.com/ccfos/nightingale/v6/front/statik"
-	"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/pkg/version"
-	"github.com/ccfos/nightingale/v6/prom"
-	"github.com/ccfos/nightingale/v6/pushgw/idents"
-	"github.com/ccfos/nightingale/v6/storage"
-	"github.com/ccfos/nightingale/v6/tdengine"
-
-	"github.com/gin-gonic/gin"
-	"github.com/rakyll/statik/fs"
-	"github.com/toolkits/pkg/ginx"
-	"github.com/toolkits/pkg/logger"
-	"github.com/toolkits/pkg/runner"
-)
-
-type Router struct {
-	HTTP              httpx.Config
-	Center            cconf.Center
-	Ibex              conf.Ibex
-	Alert             aconf.Alert
-	Operations        cconf.Operation
-	DatasourceCache   *memsto.DatasourceCacheType
-	NotifyConfigCache *memsto.NotifyConfigCacheType
-	PromClients       *prom.PromClientMap
-	TdendgineClients  *tdengine.TdengineClientMap
-	Redis             storage.Redis
-	MetaSet           *metas.Set
-	IdentSet          *idents.Set
-	TargetCache       *memsto.TargetCacheType
-	Sso               *sso.SsoClient
-	UserCache         *memsto.UserCacheType
-	UserGroupCache    *memsto.UserGroupCacheType
-	Ctx               *ctx.Context
-	HeartbeatHook     HeartbeatHookFunc
-}
-
-func New(httpConfig httpx.Config, center cconf.Center, alert aconf.Alert, ibex conf.Ibex, operations cconf.Operation, ds *memsto.DatasourceCacheType, ncc *memsto.NotifyConfigCacheType, pc *prom.PromClientMap, tdendgineClients *tdengine.TdengineClientMap, redis storage.Redis, sso *sso.SsoClient, ctx *ctx.Context, metaSet *metas.Set, idents *idents.Set, tc *memsto.TargetCacheType, uc *memsto.UserCacheType, ugc *memsto.UserGroupCacheType) *Router {
-	return &Router{
-		HTTP:              httpConfig,
-		Center:            center,
-		Alert:             alert,
-		Ibex:              ibex,
-		Operations:        operations,
-		DatasourceCache:   ds,
-		NotifyConfigCache: ncc,
-		PromClients:       pc,
-		TdendgineClients:  tdendgineClients,
-		Redis:             redis,
-		MetaSet:           metaSet,
-		IdentSet:          idents,
-		TargetCache:       tc,
-		Sso:               sso,
-		UserCache:         uc,
-		UserGroupCache:    ugc,
-		Ctx:               ctx,
-		HeartbeatHook:     func(ident string) map[string]interface{} { return nil },
-	}
-}
-
-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_HK") {
-					c.Request.Header.Set("X-Language", "zh_HK")
-				} else if strings.HasPrefix(lang, "zh") {
-					c.Request.Header.Set("X-Language", "zh_CN")
-				} 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", "zh_CN")
-			}
-		}
-		c.Next()
-	}
-}
-
-func (rt *Router) configNoRoute(r *gin.Engine, fs *http.FileSystem) {
-	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", "ttf", "md":
-			if !rt.Center.UseFileAssets {
-				c.FileFromFS(c.Request.URL.Path, *fs)
-			} else {
-				cwdarr := []string{"/"}
-				if runtime.GOOS == "windows" {
-					cwdarr[0] = ""
-				}
-				cwdarr = append(cwdarr, strings.Split(runner.Cwd, "/")...)
-				cwdarr = append(cwdarr, "pub")
-				cwdarr = append(cwdarr, strings.Split(c.Request.URL.Path, "/")...)
-				c.File(path.Join(cwdarr...))
-			}
-		default:
-			if !rt.Center.UseFileAssets {
-				c.FileFromFS("/", *fs)
-			} else {
-				cwdarr := []string{"/"}
-				if runtime.GOOS == "windows" {
-					cwdarr[0] = ""
-				}
-				cwdarr = append(cwdarr, strings.Split(runner.Cwd, "/")...)
-				cwdarr = append(cwdarr, "pub")
-				cwdarr = append(cwdarr, "index.html")
-				c.File(path.Join(cwdarr...))
-			}
-		}
-	})
-}
-
-func (rt *Router) Config(r *gin.Engine) {
-
-	r.Use(stat())
-	r.Use(languageDetector(rt.Center.I18NHeaderKey))
-	r.Use(aop.Recovery())
-
-	statikFS, err := fs.New()
-	if err != nil {
-		logger.Errorf("cannot create statik fs: %v", err)
-	}
-
-	if !rt.Center.UseFileAssets {
-		r.StaticFS("/pub", statikFS)
-	}
-
-	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)
-			pages.POST("/query-instant-batch", rt.promBatchQueryInstant)
-			pages.GET("/datasource/brief", rt.datasourceBriefs)
-
-			pages.POST("/ds-query", rt.QueryData)
-			pages.POST("/logs-query", rt.QueryLog)
-
-			pages.POST("/tdengine-databases", rt.tdengineDatabases)
-			pages.POST("/tdengine-tables", rt.tdengineTables)
-			pages.POST("/tdengine-columns", rt.tdengineColumns)
-
-		} else {
-			pages.Any("/proxy/:id/*url", rt.auth(), rt.dsProxy)
-			pages.POST("/query-range-batch", rt.auth(), rt.promBatchQueryRange)
-			pages.POST("/query-instant-batch", rt.auth(), rt.promBatchQueryInstant)
-			pages.GET("/datasource/brief", rt.auth(), rt.user(), rt.datasourceBriefs)
-
-			pages.POST("/ds-query", rt.auth(), rt.QueryData)
-			pages.POST("/logs-query", rt.auth(), rt.QueryLog)
-
-			pages.POST("/tdengine-databases", rt.auth(), rt.tdengineDatabases)
-			pages.POST("/tdengine-tables", rt.auth(), rt.tdengineTables)
-			pages.POST("/tdengine-columns", rt.auth(), rt.tdengineColumns)
-		}
-
-		pages.GET("/sql-template", rt.QuerySqlTemplate)
-		pages.POST("/auth/login", rt.jwtMock(), rt.loginPost)
-		pages.POST("/auth/logout", rt.jwtMock(), rt.auth(), rt.user(), rt.logoutPost)
-		pages.POST("/auth/refresh", rt.jwtMock(), rt.refreshPost)
-		pages.POST("/auth/captcha", rt.jwtMock(), rt.generateCaptcha)
-		pages.POST("/auth/captcha-verify", rt.jwtMock(), rt.captchaVerify)
-		pages.GET("/auth/ifshowcaptcha", rt.ifShowCaptcha)
-
-		pages.GET("/auth/sso-config", rt.ssoConfigNameGet)
-		pages.GET("/auth/rsa-config", rt.rsaConfigGet)
-		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("/auth/perms", rt.allPerms)
-
-		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("/builtin-metric-filters", rt.auth(), rt.user(), rt.metricFilterGets)
-		pages.DELETE("/builtin-metric-filters", rt.auth(), rt.user(), rt.metricFilterDel)
-		pages.POST("/builtin-metric-filters", rt.auth(), rt.user(), rt.metricFilterAdd)
-		pages.PUT("/builtin-metric-filters", rt.auth(), rt.user(), rt.metricFilterPut)
-		pages.POST("/builtin-metric-promql", rt.auth(), rt.user(), rt.getMetricPromql)
-
-		pages.POST("/builtin-metrics", rt.auth(), rt.user(), rt.perm("/builtin-metrics/add"), rt.builtinMetricsAdd)
-		pages.PUT("/builtin-metrics", rt.auth(), rt.user(), rt.perm("/builtin-metrics/put"), rt.builtinMetricsPut)
-		pages.DELETE("/builtin-metrics", rt.auth(), rt.user(), rt.perm("/builtin-metrics/del"), rt.builtinMetricsDel)
-		pages.GET("/builtin-metrics", rt.auth(), rt.user(), rt.builtinMetricsGets)
-		pages.GET("/builtin-metrics/types", rt.auth(), rt.user(), rt.builtinMetricsTypes)
-		pages.GET("/builtin-metrics/types/default", rt.auth(), rt.user(), rt.builtinMetricsDefaultTypes)
-		pages.GET("/builtin-metrics/collectors", rt.auth(), rt.user(), rt.builtinMetricsCollectors)
-
-		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.GET("/target/extra-meta", rt.auth(), rt.user(), rt.targetExtendInfoByIdent)
-		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("/integrations/icon/:cate/:name", rt.builtinIcon)
-
-		// 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/makedown/:cate", rt.builtinMarkdown)
-
-		pages.GET("/busi-groups/public-boards", rt.auth(), rt.user(), rt.perm("/dashboards"), rt.publicBoardGets)
-		pages.GET("/busi-groups/boards", rt.auth(), rt.user(), rt.perm("/dashboards"), rt.boardGetsByGids)
-		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.POST("/busi-groups/boards/clones", rt.auth(), rt.user(), rt.perm("/dashboards/add"), rt.boardBatchClone)
-
-		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/alerts-cates", rt.auth(), rt.user(), rt.builtinAlertCateGets)
-		// pages.GET("/alert-rules/builtin/list", rt.auth(), rt.user(), rt.builtinAlertRules)
-		pages.GET("/alert-rules/callbacks", rt.auth(), rt.user(), rt.alertRuleCallbacks)
-
-		pages.GET("/busi-groups/alert-rules", rt.auth(), rt.user(), rt.perm("/alert-rules"), rt.alertRuleGetsByGids)
-		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.POST("/busi-group/:id/alert-rules/import", rt.auth(), rt.user(), rt.perm("/alert-rules/add"), rt.bgrw(), rt.alertRuleAddByImport)
-		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("/alert-rule/:arid/pure", rt.auth(), rt.user(), rt.perm("/alert-rules"), rt.alertRulePureGet)
-		pages.PUT("/busi-group/alert-rule/validate", rt.auth(), rt.user(), rt.perm("/alert-rules/put"), rt.alertRuleValidation)
-		pages.POST("/relabel-test", rt.auth(), rt.user(), rt.relabelTest)
-
-		pages.GET("/busi-groups/recording-rules", rt.auth(), rt.user(), rt.perm("/recording-rules"), rt.recordingRuleGetsByGids)
-		pages.GET("/busi-group/:id/recording-rules", rt.auth(), rt.user(), rt.perm("/recording-rules"), rt.recordingRuleGets)
-		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-groups/alert-mutes", rt.auth(), rt.user(), rt.perm("/alert-mutes"), rt.alertMuteGetsByGids)
-		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/preview", rt.auth(), rt.user(), rt.perm("/alert-mutes/add"), rt.bgrw(), rt.alertMutePreview)
-		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.GET("/busi-group/:id/alert-mute/:amid", rt.auth(), rt.user(), rt.perm("/alert-mutes"), rt.alertMuteGet)
-		pages.PUT("/busi-group/:id/alert-mutes/fields", rt.auth(), rt.user(), rt.perm("/alert-mutes/put"), rt.bgrw(), rt.alertMutePutFields)
-
-		pages.GET("/busi-groups/alert-subscribes", rt.auth(), rt.user(), rt.perm("/alert-subscribes"), rt.alertSubscribeGetsByGids)
-		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.user(), rt.alertCurEventGet)
-			pages.GET("/alert-his-event/:eid", rt.auth(), rt.user(), rt.alertHisEventGet)
-		}
-
-		// card logic
-		pages.GET("/alert-cur-events/list", rt.auth(), rt.user(), rt.alertCurEventsList)
-		pages.GET("/alert-cur-events/card", rt.auth(), rt.user(), rt.alertCurEventsCard)
-		pages.POST("/alert-cur-events/card/details", rt.auth(), rt.alertCurEventsCardDetails)
-		pages.GET("/alert-his-events/list", rt.auth(), rt.user(), rt.alertHisEventsList)
-		pages.DELETE("/alert-cur-events", rt.auth(), rt.user(), rt.perm("/alert-cur-events/del"), rt.alertCurEventDel)
-		pages.GET("/alert-cur-events/stats", rt.auth(), rt.alertCurEventsStatistics)
-
-		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-groups/task-tpls", rt.auth(), rt.user(), rt.perm("/job-tpls"), rt.taskTplGetsByGids)
-		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-groups/tasks", rt.auth(), rt.user(), rt.perm("/job-tasks"), rt.taskGetsByGids)
-		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("/servers", rt.auth(), rt.user(), rt.serversGet)
-		pages.GET("/server-clusters", rt.auth(), rt.user(), rt.serverClustersGet)
-
-		pages.POST("/datasource/list", rt.auth(), rt.user(), 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.user(), rt.notifyTplGets)
-		pages.PUT("/notify-tpl/content", rt.auth(), rt.user(), rt.notifyTplUpdateContent)
-		pages.PUT("/notify-tpl", rt.auth(), rt.user(), rt.notifyTplUpdate)
-		pages.POST("/notify-tpl", rt.auth(), rt.user(), rt.notifyTplAdd)
-		pages.DELETE("/notify-tpl/:id", rt.auth(), rt.user(), rt.notifyTplDel)
-		pages.POST("/notify-tpl/preview", rt.auth(), rt.user(), 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.user(), rt.webhookGets)
-		pages.PUT("/webhooks", rt.auth(), rt.admin(), rt.webhookPuts)
-
-		pages.GET("/notify-script", rt.auth(), rt.user(), rt.perm("/help/notification-settings"), rt.notifyScriptGet)
-		pages.PUT("/notify-script", rt.auth(), rt.admin(), rt.notifyScriptPut)
-
-		pages.GET("/notify-channel", rt.auth(), rt.user(), rt.perm("/help/notification-settings"), rt.notifyChannelGets)
-		pages.PUT("/notify-channel", rt.auth(), rt.admin(), rt.notifyChannelPuts)
-
-		pages.GET("/notify-contact", rt.auth(), rt.user(), rt.perm("/help/notification-settings"), rt.notifyContactGets)
-		pages.PUT("/notify-contact", rt.auth(), rt.admin(), rt.notifyContactPuts)
-
-		pages.GET("/notify-config", rt.auth(), rt.user(), rt.perm("/help/notification-settings"), rt.notifyConfigGet)
-		pages.PUT("/notify-config", rt.auth(), rt.admin(), rt.notifyConfigPut)
-		pages.PUT("/smtp-config-test", rt.auth(), rt.admin(), rt.attemptSendEmail)
-
-		pages.GET("/es-index-pattern", rt.auth(), rt.esIndexPatternGet)
-		pages.GET("/es-index-pattern-list", rt.auth(), rt.esIndexPatternGetList)
-		pages.POST("/es-index-pattern", rt.auth(), rt.admin(), rt.esIndexPatternAdd)
-		pages.PUT("/es-index-pattern", rt.auth(), rt.admin(), rt.esIndexPatternPut)
-		pages.DELETE("/es-index-pattern", rt.auth(), rt.admin(), rt.esIndexPatternDel)
-
-		pages.GET("/embedded-dashboards", rt.auth(), rt.user(), rt.perm("/embedded-dashboards"), rt.embeddedDashboardsGet)
-		pages.PUT("/embedded-dashboards", rt.auth(), rt.user(), rt.perm("/embedded-dashboards/put"), rt.embeddedDashboardsPut)
-
-		pages.GET("/user-variable-configs", rt.auth(), rt.user(), rt.perm("/help/variable-configs"), rt.userVariableConfigGets)
-		pages.POST("/user-variable-config", rt.auth(), rt.user(), rt.perm("/help/variable-configs"), rt.userVariableConfigAdd)
-		pages.PUT("/user-variable-config/:id", rt.auth(), rt.user(), rt.perm("/help/variable-configs"), rt.userVariableConfigPut)
-		pages.DELETE("/user-variable-config/:id", rt.auth(), rt.user(), rt.perm("/help/variable-configs"), rt.userVariableConfigDel)
-
-		pages.GET("/config", rt.auth(), rt.admin(), rt.configGetByKey)
-		pages.PUT("/config", rt.auth(), rt.admin(), rt.configPutByKey)
-		pages.GET("/site-info", rt.siteInfo)
-
-		// for admin api
-		pages.GET("/user/busi-groups", rt.auth(), rt.admin(), rt.userBusiGroupsGets)
-
-		pages.GET("/builtin-components", rt.auth(), rt.user(), rt.builtinComponentsGets)
-		pages.POST("/builtin-components", rt.auth(), rt.user(), rt.perm("/built-in-components/add"), rt.builtinComponentsAdd)
-		pages.PUT("/builtin-components", rt.auth(), rt.user(), rt.perm("/built-in-components/put"), rt.builtinComponentsPut)
-		pages.DELETE("/builtin-components", rt.auth(), rt.user(), rt.perm("/built-in-components/del"), rt.builtinComponentsDel)
-
-		pages.GET("/builtin-payloads", rt.auth(), rt.user(), rt.builtinPayloadsGets)
-		pages.GET("/builtin-payloads/cates", rt.auth(), rt.user(), rt.builtinPayloadcatesGet)
-		pages.POST("/builtin-payloads", rt.auth(), rt.user(), rt.perm("/built-in-components/add"), rt.builtinPayloadsAdd)
-		pages.GET("/builtin-payload/:id", rt.auth(), rt.user(), rt.perm("/built-in-components"), rt.builtinPayloadGet)
-		pages.PUT("/builtin-payloads", rt.auth(), rt.user(), rt.perm("/built-in-components/put"), rt.builtinPayloadsPut)
-		pages.DELETE("/builtin-payloads", rt.auth(), rt.user(), rt.perm("/built-in-components/del"), rt.builtinPayloadsDel)
-	}
-
-	r.GET("/api/n9e/versions", func(c *gin.Context) {
-		v := version.Version
-		lastIndex := strings.LastIndex(version.Version, "-")
-		if lastIndex != -1 {
-			v = version.Version[:lastIndex]
-		}
-
-		gv := version.GithubVersion.Load()
-		if gv != nil {
-			ginx.NewRender(c).Data(gin.H{"version": v, "github_verison": gv.(string)}, nil)
-		} else {
-			ginx.NewRender(c).Data(gin.H{"version": v, "github_verison": ""}, nil)
-		}
-	})
-
-	if rt.HTTP.APIForService.Enable {
-		service := r.Group("/v1/n9e")
-		if len(rt.HTTP.APIForService.BasicAuth) > 0 {
-			service.Use(gin.BasicAuth(rt.HTTP.APIForService.BasicAuth))
-		}
-		{
-			service.Any("/prometheus/*url", rt.dsProxy)
-			service.POST("/users", rt.userAddPost)
-			service.PUT("/user/:id", rt.userProfilePutByService)
-			service.DELETE("/user/:id", rt.userDel)
-			service.GET("/users", rt.userFindAll)
-
-			service.GET("/user-groups", rt.userGroupGetsByService)
-			service.GET("/user-group-members", rt.userGroupMemberGetsByService)
-
-			service.GET("/targets", rt.targetGetsByService)
-			service.GET("/target/extra-meta", rt.targetExtendInfoByIdent)
-			service.POST("/target/list", rt.targetGetsByHostFilter)
-			service.DELETE("/targets", rt.targetDelByService)
-			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.PUT("/targets/bgid", rt.targetUpdateBgidByService)
-
-			service.POST("/alert-rules", rt.alertRuleAddByService)
-			service.POST("/alert-rule-add", rt.alertRuleAddOneByService)
-			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-subscribes", rt.alertSubscribeGetsByService)
-
-			service.GET("/busi-groups", rt.busiGroupGetsByService)
-
-			service.GET("/datasources", rt.datasourceGetsByService)
-			service.GET("/datasource-ids", rt.getDatasourceIds)
-			service.POST("/server-heartbeat", rt.serverHeartbeat)
-			service.GET("/servers-active", rt.serversActive)
-
-			service.GET("/recording-rules", rt.recordingRuleGetsByService)
-
-			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-cur-events-get-by-rid", rt.alertCurEventsGetByRid)
-			service.GET("/alert-his-events", rt.alertHisEventsList)
-			service.GET("/alert-his-event/:eid", rt.alertHisEventGet)
-
-			service.GET("/task-tpl/:tid", rt.taskTplGetByService)
-			service.GET("/task-tpls", rt.taskTplGetsByService)
-			service.GET("/task-tpl/statistics", rt.taskTplStatistics)
-
-			service.GET("/config/:id", rt.configGet)
-			service.GET("/configs", rt.configsGet)
-			service.GET("/config", rt.configGetByKey)
-			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)
-
-			service.GET("/statistic", rt.statistic)
-
-			service.GET("/notify-tpls", rt.notifyTplGets)
-
-			service.POST("/task-record-add", rt.taskRecordAdd)
-
-			service.GET("/user-variable/decrypt", rt.userVariableGetDecryptByService)
-
-			service.GET("/targets-of-alert-rule", rt.targetsOfAlertRule)
-
-		}
-	}
-
-	if rt.HTTP.APIForAgent.Enable {
-		heartbeat := r.Group("/v1/n9e")
-		{
-			if len(rt.HTTP.APIForAgent.BasicAuth) > 0 {
-				heartbeat.Use(gin.BasicAuth(rt.HTTP.APIForAgent.BasicAuth))
-			}
-			heartbeat.POST("/heartbeat", rt.heartbeat)
-		}
-	}
-
-	rt.configNoRoute(r, &statikFS)
-
-}
-
-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": v})
-		}
-	case error:
-		c.JSON(http.StatusOK, gin.H{"error": t.Error()})
-	}
-}

center/router/router_alert_aggr_view.go

@@ -1,79 +0,0 @@
-package router
-
-import (
-	"net/http"
-
-	"github.com/ccfos/nightingale/v6/models"
-
-	"github.com/gin-gonic/gin"
-	"github.com/toolkits/pkg/ginx"
-)
-
-// no param
-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 (rt *Router) alertAggrViewAdd(c *gin.Context) {
-	var f models.AlertAggrView
-	ginx.BindJSON(c, &f)
-
-	me := c.MustGet("user").(*models.User)
-	if !me.IsAdmin() {
-		// 管理员可以选择当前这个视图是公开呢，还是私有，普通用户的话就只能是私有的
-		f.Cate = 1
-	}
-
-	f.Id = 0
-	f.CreateBy = me.Id
-	ginx.Dangerous(f.Add(rt.Ctx))
-
-	ginx.NewRender(c).Data(f, nil)
-}
-
-// body: ids
-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(rt.Ctx, f.Ids))
-	} else {
-		ginx.NewRender(c).Message(models.AlertAggrViewDel(rt.Ctx, f.Ids, me.Id))
-	}
-}
-
-// body: id, name, rule, cate
-func (rt *Router) alertAggrViewPut(c *gin.Context) {
-	var f models.AlertAggrView
-	ginx.BindJSON(c, &f)
-
-	view, err := models.AlertAggrViewGet(rt.Ctx, "id = ?", f.Id)
-	ginx.Dangerous(err)
-
-	if view == nil {
-		ginx.NewRender(c).Message("no such item(id: %d)", f.Id)
-		return
-	}
-
-	me := c.MustGet("user").(*models.User)
-	if !me.IsAdmin() {
-		f.Cate = 1
-
-		if view.CreateBy != me.Id {
-			ginx.NewRender(c, http.StatusForbidden).Message("forbidden")
-			return
-		}
-	}
-	view.Name = f.Name
-	view.Rule = f.Rule
-	view.Cate = f.Cate
-	if view.CreateBy == 0 {
-		view.CreateBy = me.Id
-	}
-	ginx.NewRender(c).Message(view.Update(rt.Ctx))
-}

center/router/router_alert_his_event.go

@@ -1,132 +0,0 @@
-package router
-
-import (
-	"fmt"
-	"strings"
-	"time"
-
-	"github.com/ccfos/nightingale/v6/models"
-	"github.com/ccfos/nightingale/v6/pkg/ctx"
-
-	"github.com/gin-gonic/gin"
-	"github.com/toolkits/pkg/ginx"
-	"golang.org/x/exp/slices"
-)
-
-func getTimeRange(c *gin.Context) (stime, etime int64) {
-	stime = ginx.QueryInt64(c, "stime", 0)
-	etime = ginx.QueryInt64(c, "etime", 0)
-	hours := ginx.QueryInt64(c, "hours", 0)
-	now := time.Now().Unix()
-	if hours != 0 {
-		stime = now - 3600*hours
-		etime = now + 3600*24
-	}
-
-	if stime != 0 && etime == 0 {
-		etime = now + 3600*24
-	}
-	return
-}
-
-func (rt *Router) alertHisEventsList(c *gin.Context) {
-	stime, etime := getTimeRange(c)
-
-	severity := ginx.QueryInt(c, "severity", -1)
-	recovered := ginx.QueryInt(c, "is_recovered", -1)
-	query := ginx.QueryStr(c, "query", "")
-	limit := ginx.QueryInt(c, "limit", 20)
-	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, ",")
-	}
-
-	bgids, err := GetBusinessGroupIds(c, rt.Ctx, rt.Center.EventHistoryGroupView)
-	ginx.Dangerous(err)
-
-	total, err := models.AlertHisEventTotal(rt.Ctx, prods, bgids, stime, etime, severity, recovered, dsIds, cates, query)
-	ginx.Dangerous(err)
-
-	list, err := models.AlertHisEventGets(rt.Ctx, prods, bgids, 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(rt.Ctx, cache)
-	}
-
-	ginx.NewRender(c).Data(gin.H{
-		"list":  list,
-		"total": total,
-	}, nil)
-}
-
-func (rt *Router) alertHisEventGet(c *gin.Context) {
-	eid := ginx.UrlParamInt64(c, "eid")
-	event, err := models.AlertHisEventGetById(rt.Ctx, eid)
-	ginx.Dangerous(err)
-
-	if event == nil {
-		ginx.Bomb(404, "No such alert event")
-	}
-
-	if !rt.Center.AnonymousAccess.AlertDetail && rt.Center.EventHistoryGroupView {
-		rt.bgroCheck(c, event.GroupId)
-	}
-
-	ginx.NewRender(c).Data(event, err)
-}
-
-func GetBusinessGroupIds(c *gin.Context, ctx *ctx.Context, eventHistoryGroupView bool) ([]int64, error) {
-	bgid := ginx.QueryInt64(c, "bgid", 0)
-	var bgids []int64
-
-	if !eventHistoryGroupView || strings.HasPrefix(c.Request.URL.Path, "/v1") {
-		if bgid > 0 {
-			return []int64{bgid}, nil
-		}
-		return bgids, nil
-	}
-
-	user := c.MustGet("user").(*models.User)
-	if user.IsAdmin() {
-		if bgid > 0 {
-			return []int64{bgid}, nil
-		}
-		return bgids, nil
-	}
-
-	bussGroupIds, err := models.MyBusiGroupIds(ctx, user.Id)
-	if err != nil {
-		return nil, err
-	}
-
-	if len(bussGroupIds) == 0 {
-		// 如果没查到用户属于任何业务组，需要返回一个0，否则会导致查询到全部告警历史
-		return []int64{0}, nil
-	}
-
-	if bgid > 0 && !slices.Contains(bussGroupIds, bgid) {
-		return nil, fmt.Errorf("business group ID not allowed")
-	}
-
-	if bgid > 0 {
-		// Pass filter parameters, priority to use
-		return []int64{bgid}, nil
-	}
-
-	return bussGroupIds, nil
-}

center/router/router_alert_rule.go

@@ -1,455 +0,0 @@
-package router
-
-import (
-	"fmt"
-	"net/http"
-	"strconv"
-	"strings"
-	"time"
-
-	"github.com/ccfos/nightingale/v6/models"
-	"github.com/ccfos/nightingale/v6/pushgw/pconf"
-	"github.com/ccfos/nightingale/v6/pushgw/writer"
-
-	"github.com/gin-gonic/gin"
-	"github.com/prometheus/prometheus/prompb"
-	"github.com/toolkits/pkg/ginx"
-	"github.com/toolkits/pkg/i18n"
-	"github.com/toolkits/pkg/str"
-)
-
-// Return all, front-end search and paging
-func (rt *Router) alertRuleGets(c *gin.Context) {
-	busiGroupId := ginx.UrlParamInt64(c, "id")
-	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(rt.Ctx, cache)
-			ars[i].FillSeverities()
-		}
-	}
-	ginx.NewRender(c).Data(ars, err)
-}
-
-func (rt *Router) alertRuleGetsByGids(c *gin.Context) {
-	gids := str.IdsInt64(ginx.QueryStr(c, "gids", ""), ",")
-	if len(gids) > 0 {
-		for _, gid := range gids {
-			rt.bgroCheck(c, gid)
-		}
-	} else {
-		me := c.MustGet("user").(*models.User)
-		if !me.IsAdmin() {
-			var err error
-			gids, err = models.MyBusiGroupIds(rt.Ctx, me.Id)
-			ginx.Dangerous(err)
-
-			if len(gids) == 0 {
-				ginx.NewRender(c).Data([]int{}, nil)
-				return
-			}
-		}
-	}
-
-	ars, err := models.AlertRuleGetsByBGIds(rt.Ctx, gids)
-	if err == nil {
-		cache := make(map[int64]*models.UserGroup)
-		for i := 0; i < len(ars); i++ {
-			ars[i].FillNotifyGroups(rt.Ctx, cache)
-			ars[i].FillSeverities()
-		}
-	}
-	ginx.NewRender(c).Data(ars, err)
-}
-
-func (rt *Router) alertRulesGetByService(c *gin.Context) {
-	prods := []string{}
-	prodStr := ginx.QueryStr(c, "prods", "")
-	if prodStr != "" {
-		prods = strings.Split(ginx.QueryStr(c, "prods", ""), ",")
-	}
-
-	query := ginx.QueryStr(c, "query", "")
-	algorithm := ginx.QueryStr(c, "algorithm", "")
-	cluster := ginx.QueryStr(c, "cluster", "")
-	cate := ginx.QueryStr(c, "cate", "$all")
-	cates := []string{}
-	if cate != "$all" {
-		cates = strings.Split(cate, ",")
-	}
-
-	disabled := ginx.QueryInt(c, "disabled", -1)
-	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(rt.Ctx, cache)
-		}
-	}
-	ginx.NewRender(c).Data(ars, err)
-}
-
-// single or import
-func (rt *Router) alertRuleAddByFE(c *gin.Context) {
-	username := c.MustGet("username").(string)
-
-	var lst []models.AlertRule
-	ginx.BindJSON(c, &lst)
-
-	count := len(lst)
-	if count == 0 {
-		ginx.Bomb(http.StatusBadRequest, "input json is empty")
-	}
-
-	bgid := ginx.UrlParamInt64(c, "id")
-	reterr := rt.alertRuleAdd(lst, username, bgid, c.GetHeader("X-Language"))
-
-	ginx.NewRender(c).Data(reterr, nil)
-}
-
-func (rt *Router) alertRuleAddByImport(c *gin.Context) {
-	username := c.MustGet("username").(string)
-
-	var lst []models.AlertRule
-	ginx.BindJSON(c, &lst)
-
-	count := len(lst)
-	if count == 0 {
-		ginx.Bomb(http.StatusBadRequest, "input json is empty")
-	}
-
-	bgid := ginx.UrlParamInt64(c, "id")
-	reterr := rt.alertRuleAdd(lst, username, bgid, c.GetHeader("X-Language"))
-
-	ginx.NewRender(c).Data(reterr, nil)
-}
-
-func (rt *Router) alertRuleAddByService(c *gin.Context) {
-	var lst []models.AlertRule
-	ginx.BindJSON(c, &lst)
-
-	count := len(lst)
-	if count == 0 {
-		ginx.Bomb(http.StatusBadRequest, "input json is empty")
-	}
-	reterr := rt.alertRuleAddForService(lst, "")
-	ginx.NewRender(c).Data(reterr, nil)
-}
-
-func (rt *Router) alertRuleAddOneByService(c *gin.Context) {
-	var f models.AlertRule
-	ginx.BindJSON(c, &f)
-
-	err := f.FE2DB()
-	ginx.Dangerous(err)
-
-	err = f.Add(rt.Ctx)
-	ginx.NewRender(c).Data(f.Id, err)
-}
-
-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)
-	for i := 0; i < count; i++ {
-		lst[i].Id = 0
-		if username != "" {
-			lst[i].CreateBy = username
-			lst[i].UpdateBy = username
-		}
-
-		if err := lst[i].FE2DB(); err != nil {
-			reterr[lst[i].Name] = err.Error()
-			continue
-		}
-
-		if err := lst[i].Add(rt.Ctx); err != nil {
-			reterr[lst[i].Name] = err.Error()
-		} else {
-			reterr[lst[i].Name] = ""
-		}
-	}
-	return reterr
-}
-
-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)
-	for i := 0; i < count; i++ {
-		lst[i].Id = 0
-		lst[i].GroupId = bgid
-		if username != "" {
-			lst[i].CreateBy = username
-			lst[i].UpdateBy = username
-		}
-
-		if err := lst[i].FE2DB(); err != nil {
-			reterr[lst[i].Name] = i18n.Sprintf(lang, err.Error())
-			continue
-		}
-
-		if err := lst[i].Add(rt.Ctx); err != nil {
-			reterr[lst[i].Name] = i18n.Sprintf(lang, err.Error())
-		} else {
-			reterr[lst[i].Name] = ""
-		}
-	}
-	return reterr
-}
-
-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(rt.Ctx, f.Ids, ginx.UrlParamInt64(c, "id")))
-}
-
-func (rt *Router) alertRuleDelByService(c *gin.Context) {
-	var f idsForm
-	ginx.BindJSON(c, &f)
-	f.Verify()
-	ginx.NewRender(c).Message(models.AlertRuleDels(rt.Ctx, f.Ids))
-}
-
-func (rt *Router) alertRulePutByFE(c *gin.Context) {
-	var f models.AlertRule
-	ginx.BindJSON(c, &f)
-
-	arid := ginx.UrlParamInt64(c, "arid")
-	ar, err := models.AlertRuleGetById(rt.Ctx, arid)
-	ginx.Dangerous(err)
-
-	if ar == nil {
-		ginx.NewRender(c, http.StatusNotFound).Message("No such AlertRule")
-		return
-	}
-
-	rt.bgrwCheck(c, ar.GroupId)
-
-	f.UpdateBy = c.MustGet("username").(string)
-	ginx.NewRender(c).Message(ar.Update(rt.Ctx, f))
-}
-
-func (rt *Router) alertRulePutByService(c *gin.Context) {
-	var f models.AlertRule
-	ginx.BindJSON(c, &f)
-
-	arid := ginx.UrlParamInt64(c, "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(rt.Ctx, f))
-}
-
-type alertRuleFieldForm struct {
-	Ids    []int64                `json:"ids"`
-	Fields map[string]interface{} `json:"fields"`
-	Action string                 `json:"action"`
-}
-
-// 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 (rt *Router) alertRulePutFields(c *gin.Context) {
-	var f alertRuleFieldForm
-	ginx.BindJSON(c, &f)
-
-	if len(f.Fields) == 0 {
-		ginx.Bomb(http.StatusBadRequest, "fields empty")
-	}
-
-	f.Fields["update_by"] = c.MustGet("username").(string)
-	f.Fields["update_at"] = time.Now().Unix()
-
-	for i := 0; i < len(f.Ids); i++ {
-		ar, err := models.AlertRuleGetById(rt.Ctx, f.Ids[i])
-		ginx.Dangerous(err)
-
-		if ar == nil {
-			continue
-		}
-
-		if f.Action == "callback_add" {
-			// 增加一个 callback 地址
-			if callbacks, has := f.Fields["callbacks"]; has {
-				callback := callbacks.(string)
-				if !strings.Contains(ar.Callbacks, callback) {
-					ginx.Dangerous(ar.UpdateFieldsMap(rt.Ctx, map[string]interface{}{"callbacks": ar.Callbacks + " " + callback}))
-					continue
-				}
-			}
-		}
-
-		if f.Action == "callback_del" {
-			// 删除一个 callback 地址
-			if callbacks, has := f.Fields["callbacks"]; has {
-				callback := callbacks.(string)
-				ginx.Dangerous(ar.UpdateFieldsMap(rt.Ctx, map[string]interface{}{"callbacks": strings.ReplaceAll(ar.Callbacks, callback, "")}))
-				continue
-			}
-		}
-
-		for k, v := range f.Fields {
-			ginx.Dangerous(ar.UpdateColumn(rt.Ctx, k, v))
-		}
-	}
-
-	ginx.NewRender(c).Message(nil)
-}
-
-func (rt *Router) alertRuleGet(c *gin.Context) {
-	arid := ginx.UrlParamInt64(c, "arid")
-
-	ar, err := models.AlertRuleGetById(rt.Ctx, arid)
-	ginx.Dangerous(err)
-
-	if ar == nil {
-		ginx.NewRender(c, http.StatusNotFound).Message("No such AlertRule")
-		return
-	}
-
-	err = ar.FillNotifyGroups(rt.Ctx, make(map[int64]*models.UserGroup))
-	ginx.Dangerous(err)
-
-	ginx.NewRender(c).Data(ar, err)
-}
-
-func (rt *Router) alertRulePureGet(c *gin.Context) {
-	arid := ginx.UrlParamInt64(c, "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).Data(ar, err)
-}
-
-// pre validation before save rule
-func (rt *Router) alertRuleValidation(c *gin.Context) {
-	var f models.AlertRule //new
-	ginx.BindJSON(c, &f)
-
-	if len(f.NotifyChannelsJSON) > 0 && len(f.NotifyGroupsJSON) > 0 { //Validation NotifyChannels
-		ngids := make([]int64, 0, len(f.NotifyChannelsJSON))
-		for i := range f.NotifyGroupsJSON {
-			id, _ := strconv.ParseInt(f.NotifyGroupsJSON[i], 10, 64)
-			ngids = append(ngids, id)
-		}
-		userGroups := rt.UserGroupCache.GetByUserGroupIds(ngids)
-		uids := make([]int64, 0)
-		for i := range userGroups {
-			uids = append(uids, userGroups[i].UserIds...)
-		}
-		users := rt.UserCache.GetByUserIds(uids)
-		//If any users have a certain notify channel's token, it will be okay. Otherwise, this notify channel is absent of tokens.
-		ancs := make([]string, 0, len(f.NotifyChannelsJSON)) //absent Notify Channels
-		for i := range f.NotifyChannelsJSON {
-			flag := true
-			//ignore non-default channels
-			switch f.NotifyChannelsJSON[i] {
-			case models.Dingtalk, models.Wecom, models.Feishu, models.Mm,
-				models.Telegram, models.Email, models.FeishuCard:
-				// do nothing
-			default:
-				continue
-			}
-			//default channels
-			for ui := range users {
-				if _, b := users[ui].ExtractToken(f.NotifyChannelsJSON[i]); b {
-					flag = false
-					break
-				}
-			}
-			if flag {
-				ancs = append(ancs, f.NotifyChannelsJSON[i])
-			}
-		}
-
-		if len(ancs) > 0 {
-			ginx.NewRender(c).Message("All users are missing notify channel configurations. Please check for missing tokens (each channel should be configured with at least one user). %s", ancs)
-			return
-		}
-
-	}
-
-	ginx.NewRender(c).Message("")
-}
-
-func (rt *Router) alertRuleCallbacks(c *gin.Context) {
-	user := c.MustGet("user").(*models.User)
-	bussGroupIds, err := models.MyBusiGroupIds(rt.Ctx, user.Id)
-	ginx.Dangerous(err)
-
-	ars, err := models.AlertRuleGetsByBGIds(rt.Ctx, bussGroupIds)
-	ginx.Dangerous(err)
-
-	var callbacks []string
-	callbackFilter := make(map[string]struct{})
-	for i := range ars {
-		for _, callback := range ars[i].CallbacksJSON {
-			if _, ok := callbackFilter[callback]; !ok {
-				callbackFilter[callback] = struct{}{}
-				callbacks = append(callbacks, callback)
-			}
-		}
-	}
-
-	ginx.NewRender(c).Data(callbacks, nil)
-}
-
-type alertRuleTestForm struct {
-	Configs []*pconf.RelabelConfig `json:"configs"`
-	Tags    []string               `json:"tags"`
-}
-
-func (rt *Router) relabelTest(c *gin.Context) {
-	var f alertRuleTestForm
-	ginx.BindJSON(c, &f)
-
-	if len(f.Tags) == 0 || len(f.Configs) == 0 {
-		ginx.Bomb(http.StatusBadRequest, "relabel config is empty")
-	}
-
-	labels := make([]prompb.Label, len(f.Tags))
-	for i, tag := range f.Tags {
-		label := strings.Split(tag, "=")
-		if len(label) != 2 {
-			ginx.Bomb(http.StatusBadRequest, "tag:%s format error", tag)
-		}
-
-		labels[i] = prompb.Label{Name: label[0], Value: label[1]}
-	}
-
-	for i := 0; i < len(f.Configs); i++ {
-		if f.Configs[i].Replacement == "" {
-			f.Configs[i].Replacement = "$1"
-		}
-
-		if f.Configs[i].Separator == "" {
-			f.Configs[i].Separator = ";"
-		}
-
-		if f.Configs[i].Regex == "" {
-			f.Configs[i].Regex = "(.*)"
-		}
-	}
-
-	relabels := writer.Process(labels, f.Configs...)
-
-	var tags []string
-	for _, label := range relabels {
-		tags = append(tags, fmt.Sprintf("%s=%s", label.Name, label.Value))
-	}
-
-	ginx.NewRender(c).Data(tags, nil)
-}

center/router/router_alert_subscribe.go

@@ -1,161 +0,0 @@
-package router
-
-import (
-	"net/http"
-	"time"
-
-	"github.com/ccfos/nightingale/v6/models"
-
-	"github.com/gin-gonic/gin"
-	"github.com/toolkits/pkg/ginx"
-	"github.com/toolkits/pkg/str"
-)
-
-// Return all, front-end search and paging
-func (rt *Router) alertSubscribeGets(c *gin.Context) {
-	bgid := ginx.UrlParamInt64(c, "id")
-	lst, err := models.AlertSubscribeGets(rt.Ctx, bgid)
-	ginx.Dangerous(err)
-
-	ugcache := make(map[int64]*models.UserGroup)
-	rulecache := make(map[int64]string)
-
-	for i := 0; i < len(lst); i++ {
-		ginx.Dangerous(lst[i].FillUserGroups(rt.Ctx, ugcache))
-		ginx.Dangerous(lst[i].FillRuleNames(rt.Ctx, rulecache))
-		ginx.Dangerous(lst[i].FillDatasourceIds(rt.Ctx))
-		ginx.Dangerous(lst[i].DB2FE())
-	}
-
-	ginx.NewRender(c).Data(lst, err)
-}
-
-func (rt *Router) alertSubscribeGetsByGids(c *gin.Context) {
-	gids := str.IdsInt64(ginx.QueryStr(c, "gids", ""), ",")
-	if len(gids) > 0 {
-		for _, gid := range gids {
-			rt.bgroCheck(c, gid)
-		}
-	} else {
-		me := c.MustGet("user").(*models.User)
-		if !me.IsAdmin() {
-			var err error
-			gids, err = models.MyBusiGroupIds(rt.Ctx, me.Id)
-			ginx.Dangerous(err)
-
-			if len(gids) == 0 {
-				ginx.NewRender(c).Data([]int{}, nil)
-				return
-			}
-		}
-	}
-
-	lst, err := models.AlertSubscribeGetsByBGIds(rt.Ctx, gids)
-	ginx.Dangerous(err)
-
-	ugcache := make(map[int64]*models.UserGroup)
-	rulecache := make(map[int64]string)
-
-	for i := 0; i < len(lst); i++ {
-		ginx.Dangerous(lst[i].FillUserGroups(rt.Ctx, ugcache))
-		ginx.Dangerous(lst[i].FillRuleNames(rt.Ctx, rulecache))
-		ginx.Dangerous(lst[i].FillDatasourceIds(rt.Ctx))
-		ginx.Dangerous(lst[i].DB2FE())
-	}
-
-	ginx.NewRender(c).Data(lst, err)
-}
-
-func (rt *Router) alertSubscribeGet(c *gin.Context) {
-	subid := ginx.UrlParamInt64(c, "sid")
-
-	sub, err := models.AlertSubscribeGet(rt.Ctx, "id=?", subid)
-	ginx.Dangerous(err)
-
-	if sub == nil {
-		ginx.NewRender(c, 404).Message("No such alert subscribe")
-		return
-	}
-
-	ugcache := make(map[int64]*models.UserGroup)
-	ginx.Dangerous(sub.FillUserGroups(rt.Ctx, ugcache))
-
-	rulecache := make(map[int64]string)
-	ginx.Dangerous(sub.FillRuleNames(rt.Ctx, rulecache))
-	ginx.Dangerous(sub.FillDatasourceIds(rt.Ctx))
-	ginx.Dangerous(sub.DB2FE())
-
-	ginx.NewRender(c).Data(sub, nil)
-}
-
-func (rt *Router) alertSubscribeAdd(c *gin.Context) {
-	var f models.AlertSubscribe
-	ginx.BindJSON(c, &f)
-
-	username := c.MustGet("username").(string)
-	f.CreateBy = username
-	f.UpdateBy = username
-	f.GroupId = ginx.UrlParamInt64(c, "id")
-
-	if f.GroupId <= 0 {
-		ginx.Bomb(http.StatusBadRequest, "group_id invalid")
-	}
-
-	ginx.NewRender(c).Message(f.Add(rt.Ctx))
-}
-
-func (rt *Router) alertSubscribePut(c *gin.Context) {
-	var fs []models.AlertSubscribe
-	ginx.BindJSON(c, &fs)
-
-	timestamp := time.Now().Unix()
-	username := c.MustGet("username").(string)
-	for i := 0; i < len(fs); i++ {
-		fs[i].UpdateBy = username
-		fs[i].UpdateAt = timestamp
-		//After adding the function of batch subscription alert rules, rule_ids is used instead of rule_id.
-		//When the subscription rules are updated, set rule_id=0 to prevent the wrong subscription caused by the old rule_id.
-		fs[i].RuleId = 0
-		ginx.Dangerous(fs[i].Update(
-			rt.Ctx,
-			"name",
-			"disabled",
-			"prod",
-			"cate",
-			"datasource_ids",
-			"cluster",
-			"rule_id",
-			"rule_ids",
-			"tags",
-			"redefine_severity",
-			"new_severity",
-			"redefine_channels",
-			"new_channels",
-			"user_group_ids",
-			"update_at",
-			"update_by",
-			"webhooks",
-			"for_duration",
-			"redefine_webhooks",
-			"severities",
-			"extra_config",
-			"busi_groups",
-			"note",
-		))
-	}
-
-	ginx.NewRender(c).Message(nil)
-}
-
-func (rt *Router) alertSubscribeDel(c *gin.Context) {
-	var f idsForm
-	ginx.BindJSON(c, &f)
-	f.Verify()
-
-	ginx.NewRender(c).Message(models.AlertSubscribeDel(rt.Ctx, f.Ids))
-}
-
-func (rt *Router) alertSubscribeGetsByService(c *gin.Context) {
-	lst, err := models.AlertSubscribeGetsByService(rt.Ctx)
-	ginx.NewRender(c).Data(lst, err)
-}

center/router/router_board.go

@@ -1,352 +0,0 @@
-package router
-
-import (
-	"fmt"
-	"net/http"
-	"time"
-
-	"github.com/ccfos/nightingale/v6/models"
-
-	"github.com/gin-gonic/gin"
-	"github.com/toolkits/pkg/ginx"
-	"github.com/toolkits/pkg/i18n"
-	"github.com/toolkits/pkg/str"
-)
-
-type boardForm struct {
-	Name       string  `json:"name"`
-	Ident      string  `json:"ident"`
-	Tags       string  `json:"tags"`
-	Configs    string  `json:"configs"`
-	Public     int     `json:"public"`
-	PublicCate int     `json:"public_cate"`
-	Bgids      []int64 `json:"bgids"`
-}
-
-func (rt *Router) boardAdd(c *gin.Context) {
-	var f boardForm
-	ginx.BindJSON(c, &f)
-
-	me := c.MustGet("user").(*models.User)
-
-	board := &models.Board{
-		GroupId:  ginx.UrlParamInt64(c, "id"),
-		Name:     f.Name,
-		Ident:    f.Ident,
-		Tags:     f.Tags,
-		Configs:  f.Configs,
-		CreateBy: me.Username,
-		UpdateBy: me.Username,
-	}
-
-	err := board.Add(rt.Ctx)
-	ginx.Dangerous(err)
-
-	if f.Configs != "" {
-		ginx.Dangerous(models.BoardPayloadSave(rt.Ctx, board.Id, f.Configs))
-	}
-
-	ginx.NewRender(c).Data(board, nil)
-}
-
-func (rt *Router) boardGet(c *gin.Context) {
-	bid := ginx.UrlParamStr(c, "bid")
-	board, err := models.BoardGet(rt.Ctx, "id = ? or ident = ?", bid, bid)
-	ginx.Dangerous(err)
-
-	if board == nil {
-		ginx.Bomb(http.StatusNotFound, "No such dashboard")
-	}
-
-	if board.Public == 0 {
-		rt.auth()(c)
-		rt.user()(c)
-
-		me := c.MustGet("user").(*models.User)
-		if !me.IsAdmin() {
-			// check permission
-			rt.bgroCheck(c, board.GroupId)
-		}
-	}
-
-	if board.PublicCate == models.PublicLogin {
-		rt.auth()(c)
-	} else if board.PublicCate == models.PublicBusi {
-		rt.auth()(c)
-		rt.user()(c)
-
-		me := c.MustGet("user").(*models.User)
-		if !me.IsAdmin() {
-			bgids, err := models.MyBusiGroupIds(rt.Ctx, me.Id)
-			ginx.Dangerous(err)
-			if len(bgids) == 0 {
-				ginx.Bomb(http.StatusForbidden, "forbidden")
-			}
-
-			ok, err := models.BoardBusigroupCheck(rt.Ctx, board.Id, bgids)
-			ginx.Dangerous(err)
-			if !ok {
-				ginx.Bomb(http.StatusForbidden, "forbidden")
-			}
-		}
-	}
-
-	ginx.NewRender(c).Data(board, nil)
-}
-
-func (rt *Router) boardPureGet(c *gin.Context) {
-	board, err := models.BoardGetByID(rt.Ctx, ginx.UrlParamInt64(c, "bid"))
-	ginx.Dangerous(err)
-
-	if board == nil {
-		ginx.Bomb(http.StatusNotFound, "No such dashboard")
-	}
-
-	ginx.NewRender(c).Data(board, nil)
-}
-
-// bgrwCheck
-func (rt *Router) boardDel(c *gin.Context) {
-	var f idsForm
-	ginx.BindJSON(c, &f)
-	f.Verify()
-
-	for i := 0; i < len(f.Ids); i++ {
-		bid := f.Ids[i]
-
-		board, err := models.BoardGet(rt.Ctx, "id = ?", bid)
-		ginx.Dangerous(err)
-
-		if board == nil {
-			continue
-		}
-
-		me := c.MustGet("user").(*models.User)
-		if !me.IsAdmin() {
-			// check permission
-			rt.bgrwCheck(c, board.GroupId)
-		}
-
-		ginx.Dangerous(board.Del(rt.Ctx))
-	}
-
-	ginx.NewRender(c).Message(nil)
-}
-
-func (rt *Router) Board(id int64) *models.Board {
-	obj, err := models.BoardGet(rt.Ctx, "id=?", id)
-	ginx.Dangerous(err)
-
-	if obj == nil {
-		ginx.Bomb(http.StatusNotFound, "No such dashboard")
-	}
-
-	return obj
-}
-
-// bgrwCheck
-func (rt *Router) boardPut(c *gin.Context) {
-	var f boardForm
-	ginx.BindJSON(c, &f)
-
-	me := c.MustGet("user").(*models.User)
-	bo := rt.Board(ginx.UrlParamInt64(c, "bid"))
-
-	if !me.IsAdmin() {
-		// check permission
-		rt.bgrwCheck(c, bo.GroupId)
-	}
-
-	can, err := bo.CanRenameIdent(rt.Ctx, f.Ident)
-	ginx.Dangerous(err)
-
-	if !can {
-		ginx.Bomb(http.StatusOK, "Ident duplicate")
-	}
-
-	bo.Name = f.Name
-	bo.Ident = f.Ident
-	bo.Tags = f.Tags
-	bo.UpdateBy = me.Username
-	bo.UpdateAt = time.Now().Unix()
-
-	err = bo.Update(rt.Ctx, "name", "ident", "tags", "update_by", "update_at")
-	ginx.NewRender(c).Data(bo, err)
-}
-
-// bgrwCheck
-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(rt.Ctx, "id = ? or ident = ?", bid, bid)
-	ginx.Dangerous(err)
-
-	if bo == nil {
-		ginx.Bomb(http.StatusNotFound, "No such dashboard")
-	}
-
-	// check permission
-	if !me.IsAdmin() {
-		rt.bgrwCheck(c, bo.GroupId)
-	}
-
-	bo.UpdateBy = me.Username
-	bo.UpdateAt = time.Now().Unix()
-	ginx.Dangerous(bo.Update(rt.Ctx, "update_by", "update_at"))
-
-	bo.Configs = f.Configs
-	ginx.Dangerous(models.BoardPayloadSave(rt.Ctx, bo.Id, f.Configs))
-
-	ginx.NewRender(c).Data(bo, nil)
-}
-
-// bgrwCheck
-func (rt *Router) boardPutPublic(c *gin.Context) {
-	var f boardForm
-	ginx.BindJSON(c, &f)
-
-	me := c.MustGet("user").(*models.User)
-	bo := rt.Board(ginx.UrlParamInt64(c, "bid"))
-
-	// check permission
-	if !me.IsAdmin() {
-		rt.bgrwCheck(c, bo.GroupId)
-	}
-
-	bo.Public = f.Public
-	bo.PublicCate = f.PublicCate
-
-	if bo.PublicCate == models.PublicBusi {
-		err := models.BoardBusigroupUpdate(rt.Ctx, bo.Id, f.Bgids)
-		ginx.Dangerous(err)
-	} else {
-		err := models.BoardBusigroupDelByBoardId(rt.Ctx, bo.Id)
-		ginx.Dangerous(err)
-	}
-
-	bo.UpdateBy = me.Username
-	bo.UpdateAt = time.Now().Unix()
-
-	err := bo.Update(rt.Ctx, "public", "public_cate", "update_by", "update_at")
-	ginx.NewRender(c).Data(bo, err)
-}
-
-func (rt *Router) boardGets(c *gin.Context) {
-	bgid := ginx.UrlParamInt64(c, "id")
-	query := ginx.QueryStr(c, "query", "")
-
-	boards, err := models.BoardGetsByGroupId(rt.Ctx, bgid, query)
-	ginx.NewRender(c).Data(boards, err)
-}
-
-func (rt *Router) publicBoardGets(c *gin.Context) {
-	me := c.MustGet("user").(*models.User)
-
-	bgids, err := models.MyBusiGroupIds(rt.Ctx, me.Id)
-	ginx.Dangerous(err)
-
-	boardIds, err := models.BoardIdsByBusiGroupIds(rt.Ctx, bgids)
-	ginx.Dangerous(err)
-
-	boards, err := models.BoardGets(rt.Ctx, "", "public=1 and (public_cate in (?) or id in (?))", []int64{0, 1}, boardIds)
-	ginx.NewRender(c).Data(boards, err)
-}
-
-func (rt *Router) boardGetsByGids(c *gin.Context) {
-	gids := str.IdsInt64(ginx.QueryStr(c, "gids", ""), ",")
-	query := ginx.QueryStr(c, "query", "")
-
-	if len(gids) > 0 {
-		for _, gid := range gids {
-			rt.bgroCheck(c, gid)
-		}
-	} else {
-		me := c.MustGet("user").(*models.User)
-		if !me.IsAdmin() {
-			var err error
-			gids, err = models.MyBusiGroupIds(rt.Ctx, me.Id)
-			ginx.Dangerous(err)
-
-			if len(gids) == 0 {
-				ginx.NewRender(c).Data([]int{}, nil)
-				return
-			}
-		}
-	}
-
-	boardBusigroups, err := models.BoardBusigroupGets(rt.Ctx)
-	ginx.Dangerous(err)
-	m := make(map[int64][]int64)
-	for _, boardBusigroup := range boardBusigroups {
-		m[boardBusigroup.BoardId] = append(m[boardBusigroup.BoardId], boardBusigroup.BusiGroupId)
-	}
-
-	boards, err := models.BoardGetsByBGIds(rt.Ctx, gids, query)
-	ginx.Dangerous(err)
-	for i := 0; i < len(boards); i++ {
-		if ids, ok := m[boards[i].Id]; ok {
-			boards[i].Bgids = ids
-		}
-	}
-
-	ginx.NewRender(c).Data(boards, err)
-}
-
-func (rt *Router) boardClone(c *gin.Context) {
-	me := c.MustGet("user").(*models.User)
-	bo := rt.Board(ginx.UrlParamInt64(c, "bid"))
-
-	newBoard := bo.Clone(me.Username, bo.GroupId, " Cloned")
-
-	ginx.Dangerous(newBoard.Add(rt.Ctx))
-
-	// clone payload
-	payload, err := models.BoardPayloadGet(rt.Ctx, bo.Id)
-	ginx.Dangerous(err)
-
-	if payload != "" {
-		ginx.Dangerous(models.BoardPayloadSave(rt.Ctx, newBoard.Id, payload))
-	}
-
-	ginx.NewRender(c).Message(nil)
-}
-
-type boardsForm struct {
-	BoardIds []int64 `json:"board_ids"`
-	Bgids    []int64 `json:"bgids"`
-}
-
-func (rt *Router) boardBatchClone(c *gin.Context) {
-	me := c.MustGet("user").(*models.User)
-	var f boardsForm
-	ginx.BindJSON(c, &f)
-
-	for _, bgid := range f.Bgids {
-		rt.bgrwCheck(c, bgid)
-	}
-
-	reterr := make(map[string]string, len(f.BoardIds))
-	lang := c.GetHeader("X-Language")
-
-	for _, bgid := range f.Bgids {
-		for _, bid := range f.BoardIds {
-			bo := rt.Board(bid)
-			newBoard := bo.Clone(me.Username, bgid, "")
-			payload, err := models.BoardPayloadGet(rt.Ctx, bo.Id)
-			if err != nil {
-				reterr[fmt.Sprintf("%s-%d", newBoard.Name, bgid)] = i18n.Sprintf(lang, err.Error())
-				continue
-			}
-
-			if err = newBoard.AtomicAdd(rt.Ctx, payload); err != nil {
-				reterr[fmt.Sprintf("%s-%d", newBoard.Name, bgid)] = i18n.Sprintf(lang, err.Error())
-			}
-		}
-	}
-
-	ginx.NewRender(c).Data(reterr, nil)
-}

center/router/router_builtin.go

@@ -1,340 +0,0 @@
-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/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))
-}
-
-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)
-	builtinFavoritesMap, 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)
-		if len(files) == 0 {
-			continue
-		}
-
-		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 := builtinFavoritesMap[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)
-	builtinFavoritesMap, 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 := builtinFavoritesMap[dir]; ok {
-			alertCate.Favorite = true
-		}
-
-		alertCates = append(alertCates, alertCate)
-	}
-	ginx.NewRender(c).Data(alertCates, nil)
-}
-
-type builtinAlertRulesList struct {
-	Name       string                        `json:"name"`
-	IconUrl    string                        `json:"icon_url"`
-	AlertRules map[string][]models.AlertRule `json:"alert_rules"`
-	Favorite   bool                          `json:"favorite"`
-}
-
-func (rt *Router) builtinAlertRules(c *gin.Context) {
-	fp := rt.Center.BuiltinIntegrationsDir
-	if fp == "" {
-		fp = path.Join(runner.Cwd, "integrations")
-	}
-
-	me := c.MustGet("user").(*models.User)
-	builtinFavoritesMap, err := models.BuiltinCateGetByUserId(rt.Ctx, me.Id)
-	if err != nil {
-		logger.Warningf("get builtin favorites fail: %v", err)
-	}
-
-	var alertCates []builtinAlertRulesList
-	dirList, err := file.DirsUnder(fp)
-	ginx.Dangerous(err)
-	for _, dir := range dirList {
-		var alertCate builtinAlertRulesList
-		alertCate.Name = dir
-		files, err := file.FilesUnder(fp + "/" + dir + "/alerts")
-		ginx.Dangerous(err)
-		if len(files) == 0 {
-			continue
-		}
-
-		alertRules := make(map[string][]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[strings.TrimSuffix(f, ".json")] = 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 := builtinFavoritesMap[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)
-}
-
-func (rt *Router) builtinIcon(c *gin.Context) {
-	fp := rt.Center.BuiltinIntegrationsDir
-	if fp == "" {
-		fp = path.Join(runner.Cwd, "integrations")
-	}
-
-	cate := ginx.UrlParamStr(c, "cate")
-	iconPath := fp + "/" + cate + "/icon/" + ginx.UrlParamStr(c, "name")
-	c.File(path.Join(iconPath))
-}
-
-func (rt *Router) builtinMarkdown(c *gin.Context) {
-	fp := rt.Center.BuiltinIntegrationsDir
-	if fp == "" {
-		fp = path.Join(runner.Cwd, "integrations")
-	}
-	cate := ginx.UrlParamStr(c, "cate")
-
-	var markdown []byte
-	markdownDir := fp + "/" + cate + "/markdown"
-	markdownFiles, err := file.FilesUnder(markdownDir)
-	if err != nil {
-		logger.Warningf("get markdown fail: %v", err)
-	} else if len(markdownFiles) > 0 {
-		f := markdownFiles[0]
-		fn := markdownDir + "/" + f
-		markdown, err = file.ReadBytes(fn)
-		if err != nil {
-			logger.Warningf("get collect fail: %v", err)
-		}
-	}
-	ginx.NewRender(c).Data(string(markdown), nil)
-}

center/router/router_builtin_componet.go

@@ -1,66 +0,0 @@
-package router
-
-import (
-	"net/http"
-
-	"github.com/ccfos/nightingale/v6/models"
-	"github.com/gin-gonic/gin"
-	"github.com/toolkits/pkg/ginx"
-)
-
-func (rt *Router) builtinComponentsAdd(c *gin.Context) {
-	var lst []models.BuiltinComponent
-	ginx.BindJSON(c, &lst)
-
-	username := Username(c)
-
-	count := len(lst)
-	if count == 0 {
-		ginx.Bomb(http.StatusBadRequest, "input json is empty")
-	}
-
-	reterr := make(map[string]string)
-	for i := 0; i < count; i++ {
-		if err := lst[i].Add(rt.Ctx, username); err != nil {
-			reterr[lst[i].Ident] = err.Error()
-		}
-	}
-
-	ginx.NewRender(c).Data(reterr, nil)
-}
-
-func (rt *Router) builtinComponentsGets(c *gin.Context) {
-	query := ginx.QueryStr(c, "query", "")
-
-	bc, err := models.BuiltinComponentGets(rt.Ctx, query)
-	ginx.Dangerous(err)
-
-	ginx.NewRender(c).Data(bc, nil)
-}
-
-func (rt *Router) builtinComponentsPut(c *gin.Context) {
-	var req models.BuiltinComponent
-	ginx.BindJSON(c, &req)
-
-	bc, err := models.BuiltinComponentGet(rt.Ctx, "id = ?", req.ID)
-	ginx.Dangerous(err)
-
-	if bc == nil {
-		ginx.NewRender(c, http.StatusNotFound).Message("No such builtin component")
-		return
-	}
-
-	username := Username(c)
-	req.UpdatedBy = username
-
-	ginx.NewRender(c).Message(bc.Update(rt.Ctx, req))
-}
-
-func (rt *Router) builtinComponentsDel(c *gin.Context) {
-	var req idsForm
-	ginx.BindJSON(c, &req)
-
-	req.Verify()
-
-	ginx.NewRender(c).Message(models.BuiltinComponentDels(rt.Ctx, req.Ids))
-}

center/router/router_builtin_metric_filter.go

@@ -1,120 +0,0 @@
-package router
-
-import (
-	"github.com/ccfos/nightingale/v6/models"
-	"github.com/ccfos/nightingale/v6/pkg/prom"
-	"github.com/gin-gonic/gin"
-	"github.com/toolkits/pkg/ginx"
-)
-
-func (rt *Router) metricFilterGets(c *gin.Context) {
-	lst, err := models.MetricFilterGets(rt.Ctx, "")
-	ginx.Dangerous(err)
-	me := c.MustGet("user").(*models.User)
-
-	gids, err := models.MyGroupIds(rt.Ctx, me.Id)
-	ginx.Dangerous(err)
-	arr := make([]models.MetricFilter, 0)
-
-	for _, f := range lst {
-		if me.Username == f.CreateBy {
-			arr = append(arr, f)
-			continue
-		}
-
-		if HasPerm(gids, f.GroupsPerm, false) {
-			arr = append(arr, f)
-		}
-	}
-
-	ginx.NewRender(c).Data(arr, err)
-}
-
-func (rt *Router) metricFilterAdd(c *gin.Context) {
-	var f models.MetricFilter
-	ginx.BindJSON(c, &f)
-	me := c.MustGet("user").(*models.User)
-
-	f.CreateBy = me.Username
-	f.UpdateBy = me.Username
-	ginx.Dangerous(f.Add(rt.Ctx))
-	ginx.NewRender(c).Data(f, nil)
-}
-
-func (rt *Router) metricFilterDel(c *gin.Context) {
-	var f idsForm
-	ginx.BindJSON(c, &f)
-	f.Verify()
-
-	me := c.MustGet("user").(*models.User)
-
-	for _, id := range f.Ids {
-		old, err := models.MetricFilterGet(rt.Ctx, id)
-		ginx.Dangerous(err)
-
-		if me.Username != old.CreateBy {
-			gids, err := models.MyGroupIds(rt.Ctx, me.Id)
-			ginx.Dangerous(err)
-
-			if !HasPerm(gids, old.GroupsPerm, true) {
-				ginx.NewRender(c).Message("no permission")
-				return
-			}
-		}
-	}
-
-	ginx.NewRender(c).Message(models.MetricFilterDel(rt.Ctx, f.Ids))
-}
-
-func (rt *Router) metricFilterPut(c *gin.Context) {
-	var f models.MetricFilter
-	ginx.BindJSON(c, &f)
-
-	me := c.MustGet("user").(*models.User)
-	old, err := models.MetricFilterGet(rt.Ctx, f.ID)
-	ginx.Dangerous(err)
-
-	if me.Username != old.CreateBy {
-		gids, err := models.MyGroupIds(rt.Ctx, me.Id)
-		ginx.Dangerous(err)
-
-		if !HasPerm(gids, old.GroupsPerm, true) {
-			ginx.NewRender(c).Message("no permission")
-			return
-		}
-	}
-
-	f.UpdateBy = me.Username
-	ginx.NewRender(c).Message(f.Update(rt.Ctx))
-}
-
-type metricPromqlReq struct {
-	LabelFilter string `json:"label_filter"`
-	Promql      string `json:"promql"`
-}
-
-func (rt *Router) getMetricPromql(c *gin.Context) {
-	var req metricPromqlReq
-	ginx.BindJSON(c, &req)
-
-	promql := prom.AddLabelToPromQL(req.LabelFilter, req.Promql)
-	ginx.NewRender(c).Data(promql, nil)
-}
-
-func HasPerm(gids []int64, gps []models.GroupPerm, checkWrite bool) bool {
-	gmap := make(map[int64]struct{})
-	for _, gp := range gps {
-		if checkWrite && !gp.Write {
-			continue
-		}
-		gmap[gp.Gid] = struct{}{}
-	}
-
-	for _, gid := range gids {
-		if _, ok := gmap[gid]; ok {
-			return true
-		}
-	}
-
-	return false
-}

center/router/router_builtin_metrics.go

@@ -1,116 +0,0 @@
-package router
-
-import (
-	"net/http"
-	"time"
-
-	"github.com/ccfos/nightingale/v6/models"
-
-	"github.com/gin-gonic/gin"
-	"github.com/toolkits/pkg/ginx"
-	"github.com/toolkits/pkg/i18n"
-)
-
-// single or import
-func (rt *Router) builtinMetricsAdd(c *gin.Context) {
-	var lst []models.BuiltinMetric
-	ginx.BindJSON(c, &lst)
-	username := Username(c)
-	count := len(lst)
-	if count == 0 {
-		ginx.Bomb(http.StatusBadRequest, "input json is empty")
-	}
-
-	lang := c.GetHeader("X-Language")
-	if lang == "" {
-		lang = "zh_CN"
-	}
-
-	reterr := make(map[string]string)
-	for i := 0; i < count; i++ {
-		lst[i].Lang = lang
-		lst[i].UUID = time.Now().UnixNano()
-		if err := lst[i].Add(rt.Ctx, username); err != nil {
-			reterr[lst[i].Name] = i18n.Sprintf(c.GetHeader("X-Language"), err.Error())
-		}
-	}
-	ginx.NewRender(c).Data(reterr, nil)
-}
-
-func (rt *Router) builtinMetricsGets(c *gin.Context) {
-	collector := ginx.QueryStr(c, "collector", "")
-	typ := ginx.QueryStr(c, "typ", "")
-	query := ginx.QueryStr(c, "query", "")
-	limit := ginx.QueryInt(c, "limit", 20)
-	lang := c.GetHeader("X-Language")
-	unit := ginx.QueryStr(c, "unit", "")
-	if lang == "" {
-		lang = "zh_CN"
-	}
-
-	bm, err := models.BuiltinMetricGets(rt.Ctx, lang, collector, typ, query, unit, limit, ginx.Offset(c, limit))
-	ginx.Dangerous(err)
-
-	total, err := models.BuiltinMetricCount(rt.Ctx, lang, collector, typ, query, unit)
-	ginx.Dangerous(err)
-	ginx.NewRender(c).Data(gin.H{
-		"list":  bm,
-		"total": total,
-	}, nil)
-}
-
-func (rt *Router) builtinMetricsPut(c *gin.Context) {
-	var req models.BuiltinMetric
-	ginx.BindJSON(c, &req)
-
-	bm, err := models.BuiltinMetricGet(rt.Ctx, "id = ?", req.ID)
-	ginx.Dangerous(err)
-	if bm == nil {
-		ginx.NewRender(c, http.StatusNotFound).Message("No such builtin metric")
-		return
-	}
-	username := Username(c)
-
-	req.UpdatedBy = username
-	ginx.NewRender(c).Message(bm.Update(rt.Ctx, req))
-}
-
-func (rt *Router) builtinMetricsDel(c *gin.Context) {
-	var req idsForm
-	ginx.BindJSON(c, &req)
-	req.Verify()
-
-	ginx.NewRender(c).Message(models.BuiltinMetricDels(rt.Ctx, req.Ids))
-}
-
-func (rt *Router) builtinMetricsDefaultTypes(c *gin.Context) {
-	lst := []string{
-		"Linux",
-		"cAdvisor",
-		"Ping",
-		"MySQL",
-		"Redis",
-		"Kafka",
-		"Elasticsearch",
-		"PostgreSQL",
-		"MongoDB",
-		"Memcached",
-	}
-	ginx.NewRender(c).Data(lst, nil)
-}
-
-func (rt *Router) builtinMetricsTypes(c *gin.Context) {
-	collector := ginx.QueryStr(c, "collector", "")
-	query := ginx.QueryStr(c, "query", "")
-	lang := c.GetHeader("X-Language")
-
-	ginx.NewRender(c).Data(models.BuiltinMetricTypes(rt.Ctx, lang, collector, query))
-}
-
-func (rt *Router) builtinMetricsCollectors(c *gin.Context) {
-	typ := ginx.QueryStr(c, "typ", "")
-	query := ginx.QueryStr(c, "query", "")
-	lang := c.GetHeader("X-Language")
-
-	ginx.NewRender(c).Data(models.BuiltinMetricCollectors(rt.Ctx, lang, typ, query))
-}

center/router/router_builtin_payload.go

@@ -1,247 +0,0 @@
-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"
-)
-
-type Board struct {
-	Name    string      `json:"name"`
-	Tags    string      `json:"tags"`
-	Configs interface{} `json:"configs"`
-	UUID    int64       `json:"uuid"`
-}
-
-func (rt *Router) builtinPayloadsAdd(c *gin.Context) {
-	var lst []models.BuiltinPayload
-	ginx.BindJSON(c, &lst)
-
-	username := Username(c)
-
-	count := len(lst)
-	if count == 0 {
-		ginx.Bomb(http.StatusBadRequest, "input json is empty")
-	}
-
-	reterr := make(map[string]string)
-	for i := 0; i < count; i++ {
-		if lst[i].Type == "alert" {
-			if strings.HasPrefix(strings.TrimSpace(lst[i].Content), "[") {
-				// 处理多个告警规则模板的情况
-				alertRules := []models.AlertRule{}
-				if err := json.Unmarshal([]byte(lst[i].Content), &alertRules); err != nil {
-					reterr[lst[i].Name] = err.Error()
-				}
-
-				for _, rule := range alertRules {
-					if rule.UUID == 0 {
-						rule.UUID = time.Now().UnixNano()
-					}
-
-					contentBytes, err := json.Marshal(rule)
-					if err != nil {
-						reterr[rule.Name] = err.Error()
-						continue
-					}
-
-					bp := models.BuiltinPayload{
-						Type:      lst[i].Type,
-						Component: lst[i].Component,
-						Cate:      lst[i].Cate,
-						Name:      rule.Name,
-						Tags:      rule.AppendTags,
-						UUID:      rule.UUID,
-						Content:   string(contentBytes),
-						CreatedBy: username,
-						UpdatedBy: username,
-					}
-
-					if err := bp.Add(rt.Ctx, username); err != nil {
-						reterr[bp.Name] = i18n.Sprintf(c.GetHeader("X-Language"), err.Error())
-					}
-				}
-				continue
-			}
-
-			alertRule := models.AlertRule{}
-			if err := json.Unmarshal([]byte(lst[i].Content), &alertRule); err != nil {
-				reterr[lst[i].Name] = err.Error()
-				continue
-			}
-
-			if alertRule.UUID == 0 {
-				alertRule.UUID = time.Now().UnixNano()
-			}
-
-			bp := models.BuiltinPayload{
-				Type:      lst[i].Type,
-				Component: lst[i].Component,
-				Cate:      lst[i].Cate,
-				Name:      alertRule.Name,
-				Tags:      alertRule.AppendTags,
-				UUID:      alertRule.UUID,
-				Content:   lst[i].Content,
-				CreatedBy: username,
-				UpdatedBy: username,
-			}
-
-			if err := bp.Add(rt.Ctx, username); err != nil {
-				reterr[bp.Name] = i18n.Sprintf(c.GetHeader("X-Language"), err.Error())
-			}
-		} else if lst[i].Type == "dashboard" {
-			if strings.HasPrefix(strings.TrimSpace(lst[i].Content), "[") {
-				// 处理多个告警规则模板的情况
-				dashboards := []Board{}
-				if err := json.Unmarshal([]byte(lst[i].Content), &dashboards); err != nil {
-					reterr[lst[i].Name] = err.Error()
-				}
-
-				for _, dashboard := range dashboards {
-					if dashboard.UUID == 0 {
-						dashboard.UUID = time.Now().UnixNano()
-					}
-
-					contentBytes, err := json.Marshal(dashboard)
-					if err != nil {
-						reterr[dashboard.Name] = err.Error()
-						continue
-					}
-
-					bp := models.BuiltinPayload{
-						Type:      lst[i].Type,
-						Component: lst[i].Component,
-						Cate:      lst[i].Cate,
-						Name:      dashboard.Name,
-						Tags:      dashboard.Tags,
-						UUID:      dashboard.UUID,
-						Content:   string(contentBytes),
-						CreatedBy: username,
-						UpdatedBy: username,
-					}
-
-					if err := bp.Add(rt.Ctx, username); err != nil {
-						reterr[bp.Name] = i18n.Sprintf(c.GetHeader("X-Language"), err.Error())
-					}
-				}
-				continue
-			}
-
-			dashboard := Board{}
-			if err := json.Unmarshal([]byte(lst[i].Content), &dashboard); err != nil {
-				reterr[lst[i].Name] = i18n.Sprintf(c.GetHeader("X-Language"), err.Error())
-				continue
-			}
-
-			if dashboard.UUID == 0 {
-				dashboard.UUID = time.Now().UnixNano()
-			}
-
-			bp := models.BuiltinPayload{
-				Type:      lst[i].Type,
-				Component: lst[i].Component,
-				Cate:      lst[i].Cate,
-				Name:      dashboard.Name,
-				Tags:      dashboard.Tags,
-				UUID:      dashboard.UUID,
-				Content:   lst[i].Content,
-				CreatedBy: username,
-				UpdatedBy: username,
-			}
-
-			if err := bp.Add(rt.Ctx, username); err != nil {
-				reterr[bp.Name] = i18n.Sprintf(c.GetHeader("X-Language"), err.Error())
-			}
-		} else {
-			if err := lst[i].Add(rt.Ctx, username); err != nil {
-				reterr[lst[i].Name] = i18n.Sprintf(c.GetHeader("X-Language"), err.Error())
-			}
-		}
-
-	}
-
-	ginx.NewRender(c).Data(reterr, nil)
-}
-
-func (rt *Router) builtinPayloadsGets(c *gin.Context) {
-	typ := ginx.QueryStr(c, "type", "")
-	component := ginx.QueryStr(c, "component", "")
-	cate := ginx.QueryStr(c, "cate", "")
-	query := ginx.QueryStr(c, "query", "")
-
-	lst, err := models.BuiltinPayloadGets(rt.Ctx, typ, component, cate, query)
-	ginx.NewRender(c).Data(lst, err)
-}
-
-func (rt *Router) builtinPayloadcatesGet(c *gin.Context) {
-	typ := ginx.QueryStr(c, "type", "")
-	component := ginx.QueryStr(c, "component", "")
-
-	cates, err := models.BuiltinPayloadCates(rt.Ctx, typ, component)
-	ginx.NewRender(c).Data(cates, err)
-}
-
-func (rt *Router) builtinPayloadGet(c *gin.Context) {
-	id := ginx.UrlParamInt64(c, "id")
-
-	bp, err := models.BuiltinPayloadGet(rt.Ctx, "id = ?", id)
-	if err != nil {
-		ginx.Bomb(http.StatusInternalServerError, err.Error())
-	}
-	if bp == nil {
-		ginx.Bomb(http.StatusNotFound, "builtin payload not found")
-	}
-
-	ginx.NewRender(c).Data(bp, nil)
-}
-
-func (rt *Router) builtinPayloadsPut(c *gin.Context) {
-	var req models.BuiltinPayload
-	ginx.BindJSON(c, &req)
-
-	bp, err := models.BuiltinPayloadGet(rt.Ctx, "id = ?", req.ID)
-	ginx.Dangerous(err)
-
-	if bp == nil {
-		ginx.NewRender(c, http.StatusNotFound).Message("No such builtin payload")
-		return
-	}
-
-	if req.Type == "alert" {
-		alertRule := models.AlertRule{}
-		if err := json.Unmarshal([]byte(req.Content), &alertRule); err != nil {
-			ginx.Bomb(http.StatusBadRequest, err.Error())
-		}
-
-		req.Name = alertRule.Name
-		req.Tags = alertRule.AppendTags
-	} else if req.Type == "dashboard" {
-		dashboard := Board{}
-		if err := json.Unmarshal([]byte(req.Content), &dashboard); err != nil {
-			ginx.Bomb(http.StatusBadRequest, err.Error())
-		}
-
-		req.Name = dashboard.Name
-		req.Tags = dashboard.Tags
-	}
-
-	username := Username(c)
-	req.UpdatedBy = username
-
-	ginx.NewRender(c).Message(bp.Update(rt.Ctx, req))
-}
-
-func (rt *Router) builtinPayloadsDel(c *gin.Context) {
-	var req idsForm
-	ginx.BindJSON(c, &req)
-
-	req.Verify()
-
-	ginx.NewRender(c).Message(models.BuiltinPayloadDels(rt.Ctx, req.Ids))
-}

center/router/router_captcha.go

@@ -1,114 +0,0 @@
-package router
-
-import (
-	"context"
-	"time"
-
-	"github.com/ccfos/nightingale/v6/storage"
-	"github.com/gin-gonic/gin"
-	captcha "github.com/mojocn/base64Captcha"
-	"github.com/toolkits/pkg/ginx"
-	"github.com/toolkits/pkg/logger"
-)
-
-type CaptchaRedisStore struct {
-	redis storage.Redis
-}
-
-func (s *CaptchaRedisStore) Set(id string, value string) error {
-	ctx := context.Background()
-	err := s.redis.Set(ctx, id, value, time.Duration(300*time.Second)).Err()
-	if err != nil {
-		logger.Errorf("captcha id set to redis error : %s", err.Error())
-		return err
-	}
-	return nil
-}
-
-func (s *CaptchaRedisStore) Get(id string, clear bool) string {
-	ctx := context.Background()
-	val, err := s.redis.Get(ctx, id).Result()
-	if err != nil {
-		logger.Errorf("captcha id get from redis error : %s", err.Error())
-		return ""
-	}
-
-	if clear {
-		s.redis.Del(ctx, id)
-	}
-
-	return val
-}
-
-func (s *CaptchaRedisStore) Verify(id, answer string, clear bool) bool {
-
-	old := s.Get(id, clear)
-	return old == answer
-}
-
-func (rt *Router) newCaptchaRedisStore() *CaptchaRedisStore {
-	if captchaStore == nil {
-		captchaStore = &CaptchaRedisStore{redis: rt.Redis}
-	}
-	return captchaStore
-}
-
-var captchaStore *CaptchaRedisStore
-
-type CaptchaReqBody struct {
-	Id          string
-	VerifyValue string
-}
-
-// 生成图形验证码
-func (rt *Router) generateCaptcha(c *gin.Context) {
-	var driver = captcha.NewDriverMath(60, 200, 0, captcha.OptionShowHollowLine, nil, nil, []string{"wqy-microhei.ttc"})
-	cc := captcha.NewCaptcha(driver, rt.newCaptchaRedisStore())
-	//data:image/png;base64
-	id, b64s, _, err := cc.Generate()
-
-	if err != nil {
-		ginx.NewRender(c).Message(err)
-		return
-	}
-
-	ginx.NewRender(c).Data(gin.H{
-		"imgdata":   b64s,
-		"captchaid": id,
-	}, nil)
-}
-
-// 验证
-func (rt *Router) captchaVerify(c *gin.Context) {
-
-	var param CaptchaReqBody
-	ginx.BindJSON(c, &param)
-
-	//verify the captcha
-	if captchaStore.Verify(param.Id, param.VerifyValue, true) {
-		ginx.NewRender(c).Message("")
-		return
-	}
-	ginx.NewRender(c).Message("incorrect verification code")
-}
-
-// 验证码开关
-func (rt *Router) ifShowCaptcha(c *gin.Context) {
-
-	if rt.HTTP.ShowCaptcha.Enable {
-		ginx.NewRender(c).Data(gin.H{
-			"show": true,
-		}, nil)
-		return
-	}
-
-	ginx.NewRender(c).Data(gin.H{
-		"show": false,
-	}, nil)
-}
-
-// 验证
-func CaptchaVerify(id string, value string) bool {
-	//verify the captcha
-	return captchaStore.Verify(id, value, true)
-}

center/router/router_config.go

@@ -1,69 +0,0 @@
-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), &notifyChannels)
-	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), &notifyContacts)
-	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)
-}
-
-func (rt *Router) siteInfo(c *gin.Context) {
-	config, err := models.ConfigsGet(rt.Ctx, "site_info")
-	ginx.NewRender(c).Data(config, err)
-}

center/router/router_configs.go

@@ -1,91 +0,0 @@
-package router
-
-import (
-	"time"
-
-	"github.com/ccfos/nightingale/v6/models"
-
-	"github.com/gin-gonic/gin"
-	"github.com/toolkits/pkg/ginx"
-)
-
-const EMBEDDEDDASHBOARD = "embedded-dashboards"
-
-func (rt *Router) configsGet(c *gin.Context) {
-	prefix := ginx.QueryStr(c, "prefix", "")
-	limit := ginx.QueryInt(c, "limit", 10)
-	configs, err := models.ConfigsGets(rt.Ctx, prefix, limit, ginx.Offset(c, limit))
-	ginx.NewRender(c).Data(configs, err)
-}
-
-func (rt *Router) configGet(c *gin.Context) {
-	id := ginx.UrlParamInt64(c, "id")
-	configs, err := models.ConfigGet(rt.Ctx, id)
-	ginx.NewRender(c).Data(configs, err)
-}
-
-func (rt *Router) configGetByKey(c *gin.Context) {
-	config, err := models.ConfigsGet(rt.Ctx, ginx.QueryStr(c, "key"))
-	ginx.NewRender(c).Data(config, err)
-}
-
-func (rt *Router) configPutByKey(c *gin.Context) {
-	var f models.Configs
-	ginx.BindJSON(c, &f)
-	username := c.MustGet("username").(string)
-	ginx.NewRender(c).Message(models.ConfigsSetWithUname(rt.Ctx, f.Ckey, f.Cval, username))
-}
-
-func (rt *Router) embeddedDashboardsGet(c *gin.Context) {
-	config, err := models.ConfigsGet(rt.Ctx, EMBEDDEDDASHBOARD)
-	ginx.NewRender(c).Data(config, err)
-}
-
-func (rt *Router) embeddedDashboardsPut(c *gin.Context) {
-	var f models.Configs
-	ginx.BindJSON(c, &f)
-	username := c.MustGet("username").(string)
-	ginx.NewRender(c).Message(models.ConfigsSetWithUname(rt.Ctx, EMBEDDEDDASHBOARD, f.Cval, username))
-}
-
-func (rt *Router) configsDel(c *gin.Context) {
-	var f idsForm
-	ginx.BindJSON(c, &f)
-	ginx.NewRender(c).Message(models.ConfigsDel(rt.Ctx, f.Ids))
-}
-
-func (rt *Router) configsPut(c *gin.Context) { //for APIForService
-	var arr []models.Configs
-	ginx.BindJSON(c, &arr)
-	username := c.GetString("user")
-	if username == "" {
-		username = "default"
-	}
-	now := time.Now().Unix()
-	for i := 0; i < len(arr); i++ {
-		arr[i].UpdateBy = username
-		arr[i].UpdateAt = now
-		ginx.Dangerous(arr[i].Update(rt.Ctx))
-	}
-
-	ginx.NewRender(c).Message(nil)
-}
-
-func (rt *Router) configsPost(c *gin.Context) { //for APIForService
-	var arr []models.Configs
-	ginx.BindJSON(c, &arr)
-	username := c.GetString("user")
-	if username == "" {
-		username = "default"
-	}
-	now := time.Now().Unix()
-	for i := 0; i < len(arr); i++ {
-		arr[i].CreateBy = username
-		arr[i].UpdateBy = username
-		arr[i].CreateAt = now
-		arr[i].UpdateAt = now
-		ginx.Dangerous(arr[i].Add(rt.Ctx))
-	}
-
-	ginx.NewRender(c).Message(nil)
-}

center/router/router_crypto.go

@@ -1,63 +0,0 @@
-package router
-
-import (
-	"github.com/ccfos/nightingale/v6/pkg/secu"
-
-	"github.com/gin-gonic/gin"
-	"github.com/toolkits/pkg/ginx"
-)
-
-type confPropCrypto struct {
-	Data string `json:"data" binding:"required"`
-	Key  string `json:"key" binding:"required"`
-}
-
-func (rt *Router) confPropEncrypt(c *gin.Context) {
-	var f confPropCrypto
-	ginx.BindJSON(c, &f)
-
-	k := len(f.Key)
-	switch k {
-	default:
-		c.String(400, "The key length should be 16, 24 or 32")
-		return
-	case 16, 24, 32:
-		break
-	}
-
-	s, err := secu.DealWithEncrypt(f.Data, f.Key)
-	if err != nil {
-		c.String(500, err.Error())
-	}
-
-	c.JSON(200, gin.H{
-		"src":     f.Data,
-		"key":     f.Key,
-		"encrypt": s,
-	})
-}
-
-func (rt *Router) confPropDecrypt(c *gin.Context) {
-	var f confPropCrypto
-	ginx.BindJSON(c, &f)
-
-	k := len(f.Key)
-	switch k {
-	default:
-		c.String(400, "The key length should be 16, 24 or 32")
-		return
-	case 16, 24, 32:
-		break
-	}
-
-	s, err := secu.DealWithDecrypt(f.Data, f.Key)
-	if err != nil {
-		c.String(500, err.Error())
-	}
-
-	c.JSON(200, gin.H{
-		"src":     f.Data,
-		"key":     f.Key,
-		"decrypt": s,
-	})
-}

center/router/router_dashboard.go

@@ -1,19 +0,0 @@
-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"`
-}

center/router/router_datasource.go

@@ -1,249 +0,0 @@
-package router
-
-import (
-	"crypto/tls"
-	"fmt"
-	"io"
-	"net/http"
-	"net/url"
-	"strings"
-
-	"github.com/ccfos/nightingale/v6/models"
-
-	"github.com/gin-gonic/gin"
-	"github.com/toolkits/pkg/ginx"
-	"github.com/toolkits/pkg/logger"
-)
-
-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"`
-}
-
-func (rt *Router) datasourceList(c *gin.Context) {
-	if rt.DatasourceCache.DatasourceCheckHook(c) {
-		Render(c, []int{}, nil)
-		return
-	}
-
-	var req listReq
-	ginx.BindJSON(c, &req)
-
-	typ := req.Type
-	category := req.Category
-	name := req.Name
-
-	user := c.MustGet("user").(*models.User)
-
-	list, err := models.GetDatasourcesGetsBy(rt.Ctx, typ, category, name, "")
-	Render(c, rt.DatasourceCache.DatasourceFilter(list, user), err)
-}
-
-func (rt *Router) datasourceGetsByService(c *gin.Context) {
-	typ := ginx.QueryStr(c, "typ", "")
-	lst, err := models.GetDatasourcesGetsBy(rt.Ctx, typ, "", "", "")
-	ginx.NewRender(c).Data(lst, err)
-}
-
-func (rt *Router) datasourceBriefs(c *gin.Context) {
-	var dss []*models.Datasource
-	list, err := models.GetDatasourcesGetsBy(rt.Ctx, "", "", "", "")
-	ginx.Dangerous(err)
-
-	for _, item := range list {
-		item.AuthJson.BasicAuthPassword = ""
-		if item.PluginType != models.PROMETHEUS {
-			item.SettingsJson = nil
-		} else {
-			for k, v := range item.SettingsJson {
-				if strings.HasPrefix(k, "prometheus.") {
-					item.SettingsJson[strings.TrimPrefix(k, "prometheus.")] = v
-					delete(item.SettingsJson, k)
-				}
-			}
-		}
-		dss = append(dss, item)
-	}
-
-	if !rt.Center.AnonymousAccess.PromQuerier {
-		user := c.MustGet("user").(*models.User)
-		dss = rt.DatasourceCache.DatasourceFilter(dss, user)
-	}
-
-	ginx.NewRender(c).Data(dss, err)
-}
-
-func (rt *Router) datasourceUpsert(c *gin.Context) {
-	if rt.DatasourceCache.DatasourceCheckHook(c) {
-		Render(c, []int{}, nil)
-		return
-	}
-
-	var req models.Datasource
-	ginx.BindJSON(c, &req)
-	username := Username(c)
-	req.UpdatedBy = username
-
-	var err error
-	var count int64
-
-	err = DatasourceCheck(req)
-	if err != nil {
-		Dangerous(c, err)
-		return
-	}
-
-	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", "updated_by", "updated_at", "is_default")
-	}
-
-	Render(c, nil, err)
-}
-
-func DatasourceCheck(ds models.Datasource) error {
-	if ds.HTTPJson.Url == "" {
-		return fmt.Errorf("url is empty")
-	}
-
-	if !strings.HasPrefix(ds.HTTPJson.Url, "http") {
-		return fmt.Errorf("url must start with http or https")
-	}
-
-	client := &http.Client{
-		Transport: &http.Transport{
-			TLSClientConfig: &tls.Config{
-				InsecureSkipVerify: ds.HTTPJson.TLS.SkipTlsVerify,
-			},
-		},
-	}
-
-	fullURL := ds.HTTPJson.Url
-	req, err := http.NewRequest("GET", fullURL, nil)
-	if err != nil {
-		logger.Errorf("Error creating request: %v", err)
-		return fmt.Errorf("request url:%s failed", fullURL)
-	}
-
-	if ds.PluginType == models.PROMETHEUS {
-		subPath := "/api/v1/query"
-		query := url.Values{}
-		if ds.HTTPJson.IsLoki() {
-			subPath = "/api/v1/labels"
-		} else {
-			query.Add("query", "1+1")
-		}
-		fullURL = fmt.Sprintf("%s%s?%s", ds.HTTPJson.Url, subPath, query.Encode())
-
-		req, err = http.NewRequest("GET", fullURL, nil)
-		if err != nil {
-			logger.Errorf("Error creating request: %v", err)
-			return fmt.Errorf("request url:%s failed", fullURL)
-		}
-	} else if ds.PluginType == models.TDENGINE {
-		fullURL = fmt.Sprintf("%s/rest/sql", ds.HTTPJson.Url)
-		req, err = http.NewRequest("POST", fullURL, strings.NewReader("show databases"))
-		if err != nil {
-			logger.Errorf("Error creating request: %v", err)
-			return fmt.Errorf("request url:%s failed", fullURL)
-		}
-	}
-
-	if ds.PluginType == models.LOKI {
-		subPath := "/api/v1/labels"
-
-		fullURL = fmt.Sprintf("%s%s", ds.HTTPJson.Url, subPath)
-
-		req, err = http.NewRequest("GET", fullURL, nil)
-		if err != nil {
-			logger.Errorf("Error creating request: %v", err)
-			return fmt.Errorf("request url:%s failed", fullURL)
-		}
-	}
-
-	if ds.AuthJson.BasicAuthUser != "" {
-		req.SetBasicAuth(ds.AuthJson.BasicAuthUser, ds.AuthJson.BasicAuthPassword)
-	}
-
-	for k, v := range ds.HTTPJson.Headers {
-		req.Header.Set(k, v)
-	}
-
-	resp, err := client.Do(req)
-	if err != nil {
-		logger.Errorf("Error making request: %v\n", err)
-		return fmt.Errorf("request url:%s failed", fullURL)
-	}
-	defer resp.Body.Close()
-
-	if resp.StatusCode != 200 {
-		logger.Errorf("Error making request: %v\n", resp.StatusCode)
-		body, _ := io.ReadAll(resp.Body)
-		return fmt.Errorf("request url:%s failed code:%d body:%s", fullURL, resp.StatusCode, string(body))
-	}
-
-	return nil
-}
-
-func (rt *Router) datasourceGet(c *gin.Context) {
-	if rt.DatasourceCache.DatasourceCheckHook(c) {
-		Render(c, []int{}, nil)
-		return
-	}
-
-	var req models.Datasource
-	ginx.BindJSON(c, &req)
-	err := req.Get(rt.Ctx)
-	Render(c, req, err)
-}
-
-func (rt *Router) datasourceUpdataStatus(c *gin.Context) {
-	if rt.DatasourceCache.DatasourceCheckHook(c) {
-		Render(c, []int{}, nil)
-		return
-	}
-
-	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) {
-	if rt.DatasourceCache.DatasourceCheckHook(c) {
-		Render(c, []int{}, nil)
-		return
-	}
-
-	var ids []int64
-	ginx.BindJSON(c, &ids)
-	err := models.DatasourceDel(rt.Ctx, ids)
-	Render(c, nil, err)
-}
-
-func (rt *Router) getDatasourceIds(c *gin.Context) {
-	name := ginx.QueryStr(c, "name")
-	datasourceIds, err := models.GetDatasourceIdsByEngineName(rt.Ctx, name)
-
-	ginx.NewRender(c).Data(datasourceIds, err)
-}

center/router/router_es_index_pattern.go

@@ -1,81 +0,0 @@
-package router
-
-import (
-	"net/http"
-	"time"
-
-	"github.com/ccfos/nightingale/v6/models"
-	"github.com/gin-gonic/gin"
-	"github.com/toolkits/pkg/ginx"
-)
-
-// 创建 ES Index Pattern
-func (rt *Router) esIndexPatternAdd(c *gin.Context) {
-	var f models.EsIndexPattern
-	ginx.BindJSON(c, &f)
-
-	username := c.MustGet("username").(string)
-	now := time.Now().Unix()
-	f.CreateAt = now
-	f.CreateBy = username
-	f.UpdateAt = now
-	f.UpdateBy = username
-
-	err := f.Add(rt.Ctx)
-	ginx.NewRender(c).Message(err)
-}
-
-// 更新 ES Index Pattern
-func (rt *Router) esIndexPatternPut(c *gin.Context) {
-	var f models.EsIndexPattern
-	ginx.BindJSON(c, &f)
-
-	id := ginx.QueryInt64(c, "id")
-
-	esIndexPattern, err := models.EsIndexPatternGetById(rt.Ctx, id)
-	ginx.Dangerous(err)
-
-	if esIndexPattern == nil {
-		ginx.NewRender(c, http.StatusNotFound).Message("No such EsIndexPattern")
-		return
-	}
-
-	f.UpdateBy = c.MustGet("username").(string)
-
-	ginx.NewRender(c).Message(esIndexPattern.Update(rt.Ctx, f))
-}
-
-// 删除 ES Index Pattern
-func (rt *Router) esIndexPatternDel(c *gin.Context) {
-	var f idsForm
-	ginx.BindJSON(c, &f)
-
-	if len(f.Ids) == 0 {
-		ginx.Bomb(http.StatusBadRequest, "ids empty")
-	}
-
-	ginx.NewRender(c).Message(models.EsIndexPatternDel(rt.Ctx, f.Ids))
-}
-
-// ES Index Pattern列表
-func (rt *Router) esIndexPatternGetList(c *gin.Context) {
-	datasourceId := ginx.QueryInt64(c, "datasource_id", 0)
-
-	var lst []*models.EsIndexPattern
-	var err error
-	if datasourceId != 0 {
-		lst, err = models.EsIndexPatternGets(rt.Ctx, "datasource_id = ?", datasourceId)
-	} else {
-		lst, err = models.EsIndexPatternGets(rt.Ctx, "")
-	}
-
-	ginx.NewRender(c).Data(lst, err)
-}
-
-// ES Index Pattern 单个数据
-func (rt *Router) esIndexPatternGet(c *gin.Context) {
-	id := ginx.QueryInt64(c, "id")
-
-	item, err := models.EsIndexPatternGet(rt.Ctx, "id=?", id)
-	ginx.NewRender(c).Data(item, err)
-}

center/router/router_funcs.go

@@ -1,142 +0,0 @@
-package router
-
-import (
-	"net/http"
-	"strconv"
-	"strings"
-
-	"github.com/ccfos/nightingale/v6/models"
-	"github.com/ccfos/nightingale/v6/pkg/ctx"
-
-	"github.com/gin-gonic/gin"
-	"github.com/toolkits/pkg/ginx"
-)
-
-const defaultLimit = 300
-
-func (rt *Router) statistic(c *gin.Context) {
-	name := ginx.QueryStr(c, "name")
-	var model interface{}
-	var err error
-	var statistics *models.Statistics
-	switch name {
-	case "alert_mute":
-		model = models.AlertMute{}
-	case "alert_rule":
-		model = models.AlertRule{}
-	case "alert_subscribe":
-		model = models.AlertSubscribe{}
-	case "busi_group":
-		model = models.BusiGroup{}
-	case "recording_rule":
-		model = models.RecordingRule{}
-	case "target":
-		model = models.Target{}
-	case "user":
-		model = models.User{}
-	case "user_group":
-		model = models.UserGroup{}
-	case "datasource":
-		// datasource update_at is different from others
-		statistics, err = models.DatasourceStatistics(rt.Ctx)
-		ginx.NewRender(c).Data(statistics, err)
-		return
-	case "user_variable":
-		statistics, err = models.ConfigsUserVariableStatistics(rt.Ctx)
-		ginx.NewRender(c).Data(statistics, err)
-		return
-	default:
-		ginx.Bomb(http.StatusBadRequest, "invalid name")
-	}
-
-	statistics, err = models.StatisticsGet(rt.Ctx, model)
-	ginx.NewRender(c).Data(statistics, err)
-}
-
-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"`
-	IsSyncToFlashDuty bool    `json:"is_sync_to_flashduty"`
-}
-
-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
-}
-
-func Username(c *gin.Context) string {
-	username := c.GetString(gin.AuthUserKey)
-	if username == "" {
-		user := c.MustGet("user").(*models.User)
-		username = user.Username
-	}
-	return username
-}

center/router/router_heartbeat.go

@@ -1,134 +0,0 @@
-package router
-
-import (
-	"compress/gzip"
-	"encoding/json"
-	"fmt"
-	"io/ioutil"
-	"strings"
-	"time"
-
-	"github.com/ccfos/nightingale/v6/center/metas"
-	"github.com/ccfos/nightingale/v6/memsto"
-	"github.com/ccfos/nightingale/v6/models"
-	"github.com/ccfos/nightingale/v6/pkg/ctx"
-	"github.com/ccfos/nightingale/v6/pushgw/idents"
-
-	"github.com/gin-gonic/gin"
-	"github.com/toolkits/pkg/ginx"
-	"github.com/toolkits/pkg/logger"
-)
-
-type HeartbeatHookFunc func(ident string) map[string]interface{}
-
-func (rt *Router) heartbeat(c *gin.Context) {
-	req, err := HandleHeartbeat(c, rt.Ctx, rt.Alert.Heartbeat.EngineName, rt.MetaSet, rt.IdentSet, rt.TargetCache)
-	ginx.Dangerous(err)
-
-	m := rt.HeartbeatHook(req.Hostname)
-	ginx.NewRender(c).Data(m, err)
-}
-
-func HandleHeartbeat(c *gin.Context, ctx *ctx.Context, engineName string, metaSet *metas.Set, identSet *idents.Set, targetCache *memsto.TargetCacheType) (models.HostMeta, error) {
-	var bs []byte
-	var err error
-	var r *gzip.Reader
-	var req models.HostMeta
-	if c.GetHeader("Content-Encoding") == "gzip" {
-		r, err = gzip.NewReader(c.Request.Body)
-		if err != nil {
-			c.String(400, err.Error())
-			return req, err
-		}
-		defer r.Close()
-		bs, err = ioutil.ReadAll(r)
-		ginx.Dangerous(err)
-	} else {
-		defer c.Request.Body.Close()
-		bs, err = ioutil.ReadAll(c.Request.Body)
-		if err != nil {
-			return req, err
-		}
-	}
-
-	err = json.Unmarshal(bs, &req)
-	if err != nil {
-		return req, err
-	}
-
-	if req.Hostname == "" {
-		return req, fmt.Errorf("hostname is required", 400)
-	}
-
-	// maybe from pushgw
-	if req.Offset == 0 {
-		req.Offset = (time.Now().UnixMilli() - req.UnixTime)
-	}
-
-	if req.RemoteAddr == "" {
-		req.RemoteAddr = c.ClientIP()
-	}
-
-	if req.EngineName == "" {
-		req.EngineName = engineName
-	}
-
-	metaSet.Set(req.Hostname, req)
-	var items = make(map[string]struct{})
-	items[req.Hostname] = struct{}{}
-	identSet.MSet(items)
-
-	if target, has := targetCache.Get(req.Hostname); has && target != nil {
-		gid := ginx.QueryInt64(c, "gid", 0)
-		hostIp := strings.TrimSpace(req.HostIp)
-
-		field := make(map[string]interface{})
-		if gid != 0 && gid != target.GroupId {
-			field["group_id"] = gid
-		}
-
-		if hostIp != "" && hostIp != target.HostIp {
-			field["host_ip"] = hostIp
-		}
-
-		tagsMap := target.GetTagsMap()
-		tagNeedUpdate := false
-		for k, v := range req.GlobalLabels {
-			if v == "" {
-				continue
-			}
-
-			if tagv, ok := tagsMap[k]; !ok || tagv != v {
-				tagNeedUpdate = true
-				tagsMap[k] = v
-			}
-		}
-
-		if tagNeedUpdate {
-			lst := []string{}
-			for k, v := range tagsMap {
-				lst = append(lst, k+"="+v)
-			}
-			labels := strings.Join(lst, " ") + " "
-			field["tags"] = labels
-		}
-
-		if req.EngineName != "" && req.EngineName != target.EngineName {
-			field["engine_name"] = req.EngineName
-		}
-
-		if req.AgentVersion != "" && req.AgentVersion != target.AgentVersion {
-			field["agent_version"] = req.AgentVersion
-		}
-
-		if len(field) > 0 {
-			err := target.UpdateFieldsMap(ctx, field)
-			if err != nil {
-				logger.Errorf("update target fields failed, err: %v", err)
-			}
-		}
-		logger.Debugf("heartbeat field:%+v target: %v", field, *target)
-	}
-
-	return req, nil
-}

center/router/router_login.go

@@ -1,533 +0,0 @@
-package router
-
-import (
-	"encoding/base64"
-	"fmt"
-	"net/http"
-	"strconv"
-	"strings"
-
-	"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/ccfos/nightingale/v6/pkg/secu"
-
-	"github.com/dgrijalva/jwt-go"
-	"github.com/gin-gonic/gin"
-	"github.com/pelletier/go-toml/v2"
-	"github.com/toolkits/pkg/ginx"
-	"github.com/toolkits/pkg/logger"
-)
-
-type loginForm struct {
-	Username    string `json:"username" binding:"required"`
-	Password    string `json:"password" binding:"required"`
-	Captchaid   string `json:"captchaid"`
-	Verifyvalue string `json:"verifyvalue"`
-}
-
-func (rt *Router) loginPost(c *gin.Context) {
-	var f loginForm
-	ginx.BindJSON(c, &f)
-	logger.Infof("username:%s login from:%s", f.Username, c.ClientIP())
-
-	if rt.HTTP.ShowCaptcha.Enable {
-		if !CaptchaVerify(f.Captchaid, f.Verifyvalue) {
-			ginx.NewRender(c).Message("incorrect verification code")
-			return
-		}
-	}
-	authPassWord := f.Password
-	// need decode
-	if rt.HTTP.RSA.OpenRSA {
-		decPassWord, err := secu.Decrypt(f.Password, rt.HTTP.RSA.RSAPrivateKey, rt.HTTP.RSA.RSAPassWord)
-		if err != nil {
-			logger.Errorf("RSA Decrypt failed: %v username: %s", err, f.Username)
-			ginx.NewRender(c).Message(err)
-			return
-		}
-		authPassWord = decPassWord
-	}
-
-	var user *models.User
-	var err error
-	lc := rt.Sso.LDAP.Copy()
-	if lc.Enable {
-		user, err = ldapx.LdapLogin(rt.Ctx, f.Username, authPassWord, lc.DefaultRoles, lc.DefaultTeams, lc)
-		if err != nil {
-			logger.Debugf("ldap login failed: %v username: %s", err, f.Username)
-			var errLoginInN9e error
-			// to use n9e as the minimum guarantee for login
-			if user, errLoginInN9e = models.PassLogin(rt.Ctx, rt.Redis, f.Username, authPassWord); errLoginInN9e != nil {
-				ginx.NewRender(c).Message("ldap login failed: %v; n9e login failed: %v", err, errLoginInN9e)
-				return
-			}
-		} else {
-			user.RolesLst = strings.Fields(user.Roles)
-		}
-	} else {
-		user, err = models.PassLogin(rt.Ctx, rt.Redis, f.Username, authPassWord)
-		ginx.Dangerous(err)
-	}
-
-	if user == nil {
-		// Theoretically impossible
-		ginx.NewRender(c).Message("Username or password invalid")
-		return
-	}
-
-	userIdentity := fmt.Sprintf("%d-%s", user.Id, user.Username)
-
-	ts, err := rt.createTokens(rt.HTTP.JWTAuth.SigningKey, userIdentity)
-	ginx.Dangerous(err)
-	ginx.Dangerous(rt.createAuth(c.Request.Context(), userIdentity, ts))
-
-	ginx.NewRender(c).Data(gin.H{
-		"user":          user,
-		"access_token":  ts.AccessToken,
-		"refresh_token": ts.RefreshToken,
-	}, nil)
-}
-
-func (rt *Router) logoutPost(c *gin.Context) {
-	logger.Infof("username:%s logout from:%s", c.GetString("username"), c.ClientIP())
-	metadata, err := rt.extractTokenMetadata(c.Request)
-	if err != nil {
-		ginx.NewRender(c, http.StatusBadRequest).Message("failed to parse jwt token")
-		return
-	}
-
-	delErr := rt.deleteTokens(c.Request.Context(), metadata)
-	if delErr != nil {
-		ginx.NewRender(c).Message(http.StatusText(http.StatusInternalServerError))
-		return
-	}
-
-	var logoutAddr string
-	user := c.MustGet("user").(*models.User)
-	switch user.Belong {
-	case "oidc":
-		logoutAddr = rt.Sso.OIDC.GetSsoLogoutAddr()
-	case "cas":
-		logoutAddr = rt.Sso.CAS.GetSsoLogoutAddr()
-	case "oauth2":
-		logoutAddr = rt.Sso.OAuth2.GetSsoLogoutAddr()
-	}
-
-	ginx.NewRender(c).Data(logoutAddr, nil)
-}
-
-type refreshForm struct {
-	RefreshToken string `json:"refresh_token" binding:"required"`
-}
-
-func (rt *Router) refreshPost(c *gin.Context) {
-	var f refreshForm
-	ginx.BindJSON(c, &f)
-
-	// verify the token
-	token, err := jwt.Parse(f.RefreshToken, func(token *jwt.Token) (interface{}, error) {
-		if _, ok := token.Method.(*jwt.SigningMethodHMAC); !ok {
-			return nil, fmt.Errorf("unexpected jwt signing method: %v", token.Header["alg"])
-		}
-		return []byte(rt.HTTP.JWTAuth.SigningKey), nil
-	})
-
-	// if there is an error, the token must have expired
-	if err != nil {
-		// redirect to login page
-		ginx.NewRender(c, http.StatusUnauthorized).Message("refresh token expired")
-		return
-	}
-
-	// Since token is valid, get the uuid:
-	claims, ok := token.Claims.(jwt.MapClaims) //the token claims should conform to MapClaims
-	if ok && token.Valid {
-		refreshUuid, ok := claims["refresh_uuid"].(string) //convert the interface to string
-		if !ok {
-			// Theoretically impossible
-			ginx.NewRender(c, http.StatusUnauthorized).Message("failed to parse refresh_uuid from jwt")
-			return
-		}
-
-		userIdentity, ok := claims["user_identity"].(string)
-		if !ok {
-			// Theoretically impossible
-			ginx.NewRender(c, http.StatusUnauthorized).Message("failed to parse user_identity from jwt")
-			return
-		}
-
-		userid, err := strconv.ParseInt(strings.Split(userIdentity, "-")[0], 10, 64)
-		if err != nil {
-			ginx.NewRender(c, http.StatusUnauthorized).Message("failed to parse user_identity from jwt")
-			return
-		}
-
-		u, err := models.UserGetById(rt.Ctx, userid)
-		if err != nil {
-			ginx.NewRender(c, http.StatusInternalServerError).Message("failed to query user by id")
-			return
-		}
-
-		if u == nil {
-			// user already deleted
-			ginx.NewRender(c, http.StatusUnauthorized).Message("user already deleted")
-			return
-		}
-
-		// Delete the previous Refresh Token
-		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
-		rt.deleteAuth(c.Request.Context(), strings.Split(refreshUuid, "++")[0])
-
-		// Create new pairs of refresh and access tokens
-		ts, err := rt.createTokens(rt.HTTP.JWTAuth.SigningKey, userIdentity)
-		ginx.Dangerous(err)
-		ginx.Dangerous(rt.createAuth(c.Request.Context(), userIdentity, ts))
-
-		ginx.NewRender(c).Data(gin.H{
-			"access_token":  ts.AccessToken,
-			"refresh_token": ts.RefreshToken,
-		}, nil)
-	} else {
-		// redirect to login page
-		ginx.NewRender(c, http.StatusUnauthorized).Message("refresh token expired")
-	}
-}
-
-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(rt.Ctx, userid)
-		ginx.Dangerous(err)
-		if user == nil {
-			ginx.Bomb(200, "user not found")
-		}
-
-		if user.Username != "" { // already login
-			ginx.NewRender(c).Data(redirect, nil)
-			return
-		}
-	}
-
-	if !rt.Sso.OIDC.Enable {
-		ginx.NewRender(c).Data("", nil)
-		return
-	}
-
-	redirect, err := rt.Sso.OIDC.Authorize(rt.Redis, redirect)
-	ginx.Dangerous(err)
-
-	ginx.NewRender(c).Data(redirect, err)
-}
-
-type CallbackOutput struct {
-	Redirect     string       `json:"redirect"`
-	User         *models.User `json:"user"`
-	AccessToken  string       `json:"access_token"`
-	RefreshToken string       `json:"refresh_token"`
-}
-
-func (rt *Router) loginCallback(c *gin.Context) {
-	code := ginx.QueryStr(c, "code", "")
-	state := ginx.QueryStr(c, "state", "")
-
-	ret, err := rt.Sso.OIDC.Callback(rt.Redis, c.Request.Context(), code, state)
-	if err != nil {
-		logger.Errorf("sso_callback fail. code:%s, state:%s, get ret: %+v. error: %v", code, state, ret, err)
-		ginx.NewRender(c).Data(CallbackOutput{}, err)
-		return
-	}
-
-	user, err := models.UserGet(rt.Ctx, "username=?", ret.Username)
-	ginx.Dangerous(err)
-
-	if user != nil {
-		if rt.Sso.OIDC.CoverAttributes {
-			updatedFields := user.UpdateSsoFields("oidc", ret.Nickname, ret.Phone, ret.Email)
-			ginx.Dangerous(user.Update(rt.Ctx, "update_at", updatedFields...))
-		}
-	} else {
-		user = new(models.User)
-		user.FullSsoFields("oidc", ret.Username, ret.Nickname, ret.Phone, ret.Email, rt.Sso.OIDC.DefaultRoles)
-		// create user from oidc
-		ginx.Dangerous(user.Add(rt.Ctx))
-
-		if len(rt.Sso.OIDC.DefaultTeams) > 0 {
-			for _, gid := range rt.Sso.OIDC.DefaultTeams {
-				err = models.UserGroupMemberAdd(rt.Ctx, gid, user.Id)
-				if err != nil {
-					logger.Errorf("user:%v UserGroupMemberAdd: %s", user, err)
-				}
-			}
-		}
-	}
-
-	// set user login state
-	userIdentity := fmt.Sprintf("%d-%s", user.Id, user.Username)
-	ts, err := rt.createTokens(rt.HTTP.JWTAuth.SigningKey, userIdentity)
-	ginx.Dangerous(err)
-	ginx.Dangerous(rt.createAuth(c.Request.Context(), userIdentity, ts))
-
-	redirect := "/"
-	if ret.Redirect != "/login" {
-		redirect = ret.Redirect
-	}
-
-	ginx.NewRender(c).Data(CallbackOutput{
-		Redirect:     redirect,
-		User:         user,
-		AccessToken:  ts.AccessToken,
-		RefreshToken: ts.RefreshToken,
-	}, nil)
-}
-
-type RedirectOutput struct {
-	Redirect string `json:"redirect"`
-	State    string `json:"state"`
-}
-
-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(rt.Ctx, userid)
-		ginx.Dangerous(err)
-		if user == nil {
-			ginx.Bomb(200, "user not found")
-		}
-
-		if user.Username != "" { // already login
-			ginx.NewRender(c).Data(redirect, nil)
-			return
-		}
-	}
-
-	if !rt.Sso.CAS.Enable {
-		logger.Error("cas is not enable")
-		ginx.NewRender(c).Data("", nil)
-		return
-	}
-
-	redirect, state, err := rt.Sso.CAS.Authorize(rt.Redis, redirect)
-
-	ginx.Dangerous(err)
-	ginx.NewRender(c).Data(RedirectOutput{
-		Redirect: redirect,
-		State:    state,
-	}, err)
-}
-
-func (rt *Router) loginCallbackCas(c *gin.Context) {
-	ticket := ginx.QueryStr(c, "ticket", "")
-	state := ginx.QueryStr(c, "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(rt.Ctx, "username=?", ret.Username)
-	if err != nil {
-		logger.Errorf("UserGet: %s", err)
-	}
-	ginx.Dangerous(err)
-	if user != nil {
-		if rt.Sso.CAS.CoverAttributes {
-			updatedFields := user.UpdateSsoFields("cas", ret.Nickname, ret.Phone, ret.Email)
-			ginx.Dangerous(user.Update(rt.Ctx, "update_at", updatedFields...))
-		}
-	} else {
-		user = new(models.User)
-		user.FullSsoFields("cas", ret.Username, ret.Nickname, ret.Phone, ret.Email, rt.Sso.CAS.DefaultRoles)
-		// create user from cas
-		ginx.Dangerous(user.Add(rt.Ctx))
-	}
-
-	// set user login state
-	userIdentity := fmt.Sprintf("%d-%s", user.Id, user.Username)
-	ts, err := rt.createTokens(rt.HTTP.JWTAuth.SigningKey, userIdentity)
-	if err != nil {
-		logger.Errorf("createTokens: %s", err)
-	}
-	ginx.Dangerous(err)
-	ginx.Dangerous(rt.createAuth(c.Request.Context(), userIdentity, ts))
-
-	redirect := "/"
-	if ret.Redirect != "/login" {
-		redirect = ret.Redirect
-	}
-	ginx.NewRender(c).Data(CallbackOutput{
-		Redirect:     redirect,
-		User:         user,
-		AccessToken:  ts.AccessToken,
-		RefreshToken: ts.RefreshToken,
-	}, nil)
-}
-
-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(rt.Ctx, userid)
-		ginx.Dangerous(err)
-		if user == nil {
-			ginx.Bomb(200, "user not found")
-		}
-
-		if user.Username != "" { // already login
-			ginx.NewRender(c).Data(redirect, nil)
-			return
-		}
-	}
-
-	if !rt.Sso.OAuth2.Enable {
-		ginx.NewRender(c).Data("", nil)
-		return
-	}
-
-	redirect, err := rt.Sso.OAuth2.Authorize(rt.Redis, redirect)
-	ginx.Dangerous(err)
-
-	ginx.NewRender(c).Data(redirect, err)
-}
-
-func (rt *Router) loginCallbackOAuth(c *gin.Context) {
-	code := ginx.QueryStr(c, "code", "")
-	state := ginx.QueryStr(c, "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(rt.Ctx, "username=?", ret.Username)
-	ginx.Dangerous(err)
-
-	if user != nil {
-		if rt.Sso.OAuth2.CoverAttributes {
-			updatedFields := user.UpdateSsoFields("oauth2", ret.Nickname, ret.Phone, ret.Email)
-			ginx.Dangerous(user.Update(rt.Ctx, "update_at", updatedFields...))
-		}
-	} else {
-		user = new(models.User)
-		user.FullSsoFields("oauth2", ret.Username, ret.Nickname, ret.Phone, ret.Email, rt.Sso.OAuth2.DefaultRoles)
-		// create user from oidc
-		ginx.Dangerous(user.Add(rt.Ctx))
-	}
-
-	// set user login state
-	userIdentity := fmt.Sprintf("%d-%s", user.Id, user.Username)
-	ts, err := rt.createTokens(rt.HTTP.JWTAuth.SigningKey, userIdentity)
-	ginx.Dangerous(err)
-	ginx.Dangerous(rt.createAuth(c.Request.Context(), userIdentity, ts))
-
-	redirect := "/"
-	if ret.Redirect != "/login" {
-		redirect = ret.Redirect
-	}
-
-	ginx.NewRender(c).Data(CallbackOutput{
-		Redirect:     redirect,
-		User:         user,
-		AccessToken:  ts.AccessToken,
-		RefreshToken: ts.RefreshToken,
-	}, nil)
-}
-
-type SsoConfigOutput struct {
-	OidcDisplayName  string `json:"oidcDisplayName"`
-	CasDisplayName   string `json:"casDisplayName"`
-	OauthDisplayName string `json:"oauthDisplayName"`
-}
-
-func (rt *Router) ssoConfigNameGet(c *gin.Context) {
-	var oidcDisplayName, casDisplayName, oauthDisplayName string
-	if rt.Sso.OIDC != nil {
-		oidcDisplayName = rt.Sso.OIDC.GetDisplayName()
-	}
-
-	if rt.Sso.CAS != nil {
-		casDisplayName = rt.Sso.CAS.GetDisplayName()
-	}
-
-	if rt.Sso.OAuth2 != nil {
-		oauthDisplayName = rt.Sso.OAuth2.GetDisplayName()
-	}
-
-	ginx.NewRender(c).Data(SsoConfigOutput{
-		OidcDisplayName:  oidcDisplayName,
-		CasDisplayName:   casDisplayName,
-		OauthDisplayName: oauthDisplayName,
-	}, 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)
-		rt.Sso.OIDC, err = oidcx.New(config)
-		ginx.Dangerous(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)
-}
-
-type RSAConfigOutput struct {
-	OpenRSA      bool
-	RSAPublicKey string
-}
-
-func (rt *Router) rsaConfigGet(c *gin.Context) {
-	publicKey := ""
-	if len(rt.HTTP.RSA.RSAPublicKey) > 0 {
-		publicKey = base64.StdEncoding.EncodeToString(rt.HTTP.RSA.RSAPublicKey)
-	}
-	ginx.NewRender(c).Data(RSAConfigOutput{
-		OpenRSA:      rt.HTTP.RSA.OpenRSA,
-		RSAPublicKey: publicKey,
-	}, nil)
-}

center/router/router_metric_view.go

@@ -1,76 +0,0 @@
-package router
-
-import (
-	"net/http"
-
-	"github.com/ccfos/nightingale/v6/models"
-
-	"github.com/gin-gonic/gin"
-	"github.com/toolkits/pkg/ginx"
-)
-
-// no param
-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 (rt *Router) metricViewAdd(c *gin.Context) {
-	var f models.MetricView
-	ginx.BindJSON(c, &f)
-
-	me := c.MustGet("user").(*models.User)
-	if !me.IsAdmin() {
-		// 管理员可以选择当前这个视图是公开呢，还是私有，普通用户的话就只能是私有的
-		f.Cate = 1
-	}
-
-	f.Id = 0
-	f.CreateBy = me.Id
-
-	ginx.Dangerous(f.Add(rt.Ctx))
-
-	ginx.NewRender(c).Data(f, nil)
-}
-
-// body: ids
-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(rt.Ctx, f.Ids))
-	} else {
-		ginx.NewRender(c).Message(models.MetricViewDel(rt.Ctx, f.Ids, me.Id))
-	}
-}
-
-// body: id, name, configs, cate
-func (rt *Router) metricViewPut(c *gin.Context) {
-	var f models.MetricView
-	ginx.BindJSON(c, &f)
-
-	view, err := models.MetricViewGet(rt.Ctx, "id = ?", f.Id)
-	ginx.Dangerous(err)
-
-	if view == nil {
-		ginx.NewRender(c).Message("no such item(id: %d)", f.Id)
-		return
-	}
-
-	me := c.MustGet("user").(*models.User)
-	if !me.IsAdmin() {
-		f.Cate = 1
-
-		// 如果是普通用户，只能修改自己的
-		if view.CreateBy != me.Id {
-			ginx.NewRender(c, http.StatusForbidden).Message("forbidden")
-			return
-		}
-	}
-
-	ginx.NewRender(c).Message(view.Update(rt.Ctx, f.Name, f.Configs, f.Cate, me.Id))
-}

center/router/router_mute.go

@@ -1,166 +0,0 @@
-package router
-
-import (
-	"net/http"
-	"strings"
-	"time"
-
-	"github.com/ccfos/nightingale/v6/alert/common"
-	"github.com/ccfos/nightingale/v6/models"
-
-	"github.com/gin-gonic/gin"
-	"github.com/toolkits/pkg/ginx"
-	"github.com/toolkits/pkg/str"
-)
-
-// Return all, front-end search and paging
-func (rt *Router) alertMuteGetsByBG(c *gin.Context) {
-	bgid := ginx.UrlParamInt64(c, "id")
-	lst, err := models.AlertMuteGetsByBG(rt.Ctx, bgid)
-
-	ginx.NewRender(c).Data(lst, err)
-}
-
-func (rt *Router) alertMuteGetsByGids(c *gin.Context) {
-	gids := str.IdsInt64(ginx.QueryStr(c, "gids", ""), ",")
-	if len(gids) > 0 {
-		for _, gid := range gids {
-			rt.bgroCheck(c, gid)
-		}
-	} else {
-		me := c.MustGet("user").(*models.User)
-		if !me.IsAdmin() {
-			var err error
-			gids, err = models.MyBusiGroupIds(rt.Ctx, me.Id)
-			ginx.Dangerous(err)
-
-			if len(gids) == 0 {
-				ginx.NewRender(c).Data([]int{}, nil)
-				return
-			}
-		}
-	}
-
-	lst, err := models.AlertMuteGetsByBGIds(rt.Ctx, gids)
-
-	ginx.NewRender(c).Data(lst, err)
-}
-
-func (rt *Router) alertMuteGets(c *gin.Context) {
-	prods := strings.Fields(ginx.QueryStr(c, "prods", ""))
-	bgid := ginx.QueryInt64(c, "bgid", -1)
-	query := ginx.QueryStr(c, "query", "")
-	lst, err := models.AlertMuteGets(rt.Ctx, prods, bgid, query)
-
-	ginx.NewRender(c).Data(lst, err)
-}
-
-func (rt *Router) alertMuteAdd(c *gin.Context) {
-
-	var f models.AlertMute
-	ginx.BindJSON(c, &f)
-
-	username := c.MustGet("username").(string)
-	f.CreateBy = username
-	f.GroupId = ginx.UrlParamInt64(c, "id")
-	ginx.NewRender(c).Message(f.Add(rt.Ctx))
-}
-
-// Preview events (alert_cur_event) that match the mute strategy based on the following criteria:
-// business group ID (group_id, group_id), product (prod, rule_prod),
-// alert event severity (severities, severity), and event tags (tags, tags).
-// For products of type not 'host', also consider the category (cate, cate) and datasource ID (datasource_ids, datasource_id).
-func (rt *Router) alertMutePreview(c *gin.Context) {
-	//Generally the match of events would be less.
-
-	var f models.AlertMute
-	ginx.BindJSON(c, &f)
-	f.GroupId = ginx.UrlParamInt64(c, "id")
-	ginx.Dangerous(f.Verify()) //verify and parse tags json to ITags
-	events, err := models.AlertCurEventGetsFromAlertMute(rt.Ctx, &f)
-	ginx.Dangerous(err)
-
-	matchEvents := make([]*models.AlertCurEvent, 0, len(events))
-	for i := 0; i < len(events); i++ {
-		events[i].DB2Mem()
-		if common.MatchTags(events[i].TagsMap, f.ITags) {
-			matchEvents = append(matchEvents, events[i])
-		}
-	}
-	ginx.NewRender(c).Data(matchEvents, err)
-
-}
-
-func (rt *Router) alertMuteAddByService(c *gin.Context) {
-	var f models.AlertMute
-	ginx.BindJSON(c, &f)
-
-	err := f.Add(rt.Ctx)
-	ginx.NewRender(c).Data(f.Id, err)
-}
-
-func (rt *Router) alertMuteDel(c *gin.Context) {
-	var f idsForm
-	ginx.BindJSON(c, &f)
-	f.Verify()
-
-	ginx.NewRender(c).Message(models.AlertMuteDel(rt.Ctx, f.Ids))
-}
-
-// alertMuteGet returns the alert mute by ID
-func (rt *Router) alertMuteGet(c *gin.Context) {
-	amid := ginx.UrlParamInt64(c, "amid")
-	am, err := models.AlertMuteGetById(rt.Ctx, amid)
-	am.DB2FE()
-	ginx.NewRender(c).Data(am, err)
-}
-
-func (rt *Router) alertMutePutByFE(c *gin.Context) {
-	var f models.AlertMute
-	ginx.BindJSON(c, &f)
-
-	amid := ginx.UrlParamInt64(c, "amid")
-	am, err := models.AlertMuteGetById(rt.Ctx, amid)
-	ginx.Dangerous(err)
-
-	if am == nil {
-		ginx.NewRender(c, http.StatusNotFound).Message("No such AlertMute")
-		return
-	}
-
-	rt.bgrwCheck(c, am.GroupId)
-
-	f.UpdateBy = c.MustGet("username").(string)
-	ginx.NewRender(c).Message(am.Update(rt.Ctx, f))
-}
-
-type alertMuteFieldForm struct {
-	Ids    []int64                `json:"ids"`
-	Fields map[string]interface{} `json:"fields"`
-}
-
-func (rt *Router) alertMutePutFields(c *gin.Context) {
-	var f alertMuteFieldForm
-	ginx.BindJSON(c, &f)
-
-	if len(f.Fields) == 0 {
-		ginx.Bomb(http.StatusBadRequest, "fields empty")
-	}
-
-	f.Fields["update_by"] = c.MustGet("username").(string)
-	f.Fields["update_at"] = time.Now().Unix()
-
-	for i := 0; i < len(f.Ids); i++ {
-		am, err := models.AlertMuteGetById(rt.Ctx, f.Ids[i])
-		ginx.Dangerous(err)
-
-		if am == nil {
-			continue
-		}
-
-		am.FE2DB()
-		ginx.Dangerous(am.UpdateFieldsMap(rt.Ctx, f.Fields))
-	}
-
-	ginx.NewRender(c).Message(nil)
-}

center/router/router_mw.go

@@ -1,440 +0,0 @@
-package router
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"net/http"
-	"strconv"
-	"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"
-)
-
-type AccessDetails struct {
-	AccessUuid   string
-	UserIdentity string
-}
-
-func (rt *Router) handleProxyUser(c *gin.Context) *models.User {
-	headerUserNameKey := rt.HTTP.ProxyAuth.HeaderUserNameKey
-	username := c.GetHeader(headerUserNameKey)
-	if username == "" {
-		ginx.Bomb(http.StatusUnauthorized, "unauthorized")
-	}
-
-	user, err := models.UserGetByUsername(rt.Ctx, username)
-	if err != nil {
-		ginx.Bomb(http.StatusInternalServerError, err.Error())
-	}
-
-	if user == nil {
-		now := time.Now().Unix()
-		user = &models.User{
-			Username: username,
-			Nickname: username,
-			Roles:    strings.Join(rt.HTTP.ProxyAuth.DefaultRoles, " "),
-			CreateAt: now,
-			UpdateAt: now,
-			CreateBy: "system",
-			UpdateBy: "system",
-		}
-		err = user.Add(rt.Ctx)
-		if err != nil {
-			ginx.Bomb(http.StatusInternalServerError, err.Error())
-		}
-	}
-	return user
-}
-
-func (rt *Router) proxyAuth() gin.HandlerFunc {
-	return func(c *gin.Context) {
-		user := rt.handleProxyUser(c)
-		c.Set("userid", user.Id)
-		c.Set("username", user.Username)
-		c.Next()
-	}
-}
-
-func (rt *Router) jwtAuth() gin.HandlerFunc {
-	return func(c *gin.Context) {
-		metadata, err := rt.extractTokenMetadata(c.Request)
-		if err != nil {
-			ginx.Bomb(http.StatusUnauthorized, "unauthorized")
-		}
-
-		userIdentity, err := rt.fetchAuth(c.Request.Context(), metadata.AccessUuid)
-		if err != nil {
-			ginx.Bomb(http.StatusUnauthorized, "unauthorized")
-		}
-
-		// ${userid}-${username}
-		arr := strings.SplitN(userIdentity, "-", 2)
-		if len(arr) != 2 {
-			ginx.Bomb(http.StatusUnauthorized, "unauthorized")
-		}
-
-		userid, err := strconv.ParseInt(arr[0], 10, 64)
-		if err != nil {
-			ginx.Bomb(http.StatusUnauthorized, "unauthorized")
-		}
-
-		c.Set("userid", userid)
-		c.Set("username", arr[1])
-
-		c.Next()
-	}
-}
-
-func (rt *Router) Auth() gin.HandlerFunc {
-	return rt.auth()
-}
-
-func (rt *Router) auth() gin.HandlerFunc {
-	if rt.HTTP.ProxyAuth.Enable {
-		return rt.proxyAuth()
-	} else {
-		return rt.jwtAuth()
-	}
-}
-
-// if proxy auth is enabled, mock jwt login/logout/refresh request
-func (rt *Router) jwtMock() gin.HandlerFunc {
-	return func(c *gin.Context) {
-		if !rt.HTTP.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 := rt.handleProxyUser(c)
-		ginx.NewRender(c).Data(gin.H{
-			"user":          user,
-			"access_token":  "",
-			"refresh_token": "",
-		}, nil)
-		c.Abort()
-	}
-}
-
-func (rt *Router) User() gin.HandlerFunc {
-	return rt.user()
-}
-
-func (rt *Router) user() gin.HandlerFunc {
-	return func(c *gin.Context) {
-		userid := c.MustGet("userid").(int64)
-
-		user, err := models.UserGetById(rt.Ctx, userid)
-		if err != nil {
-			ginx.Bomb(http.StatusUnauthorized, "unauthorized")
-		}
-
-		if user == nil {
-			ginx.Bomb(http.StatusUnauthorized, "unauthorized")
-		}
-
-		c.Set("user", user)
-		c.Set("isadmin", user.IsAdmin())
-		// Update user.LastActiveTime
-		rt.UserCache.SetLastActiveTime(user.Id, time.Now().Unix())
-		c.Next()
-	}
-}
-
-func (rt *Router) userGroupWrite() gin.HandlerFunc {
-	return func(c *gin.Context) {
-		me := c.MustGet("user").(*models.User)
-		ug := UserGroup(rt.Ctx, ginx.UrlParamInt64(c, "id"))
-
-		can, err := me.CanModifyUserGroup(rt.Ctx, ug)
-		ginx.Dangerous(err)
-
-		if !can {
-			ginx.Bomb(http.StatusForbidden, "forbidden")
-		}
-
-		c.Set("user_group", ug)
-		c.Next()
-	}
-}
-
-func (rt *Router) bgro() gin.HandlerFunc {
-	return func(c *gin.Context) {
-		me := c.MustGet("user").(*models.User)
-		bg := BusiGroup(rt.Ctx, ginx.UrlParamInt64(c, "id"))
-
-		can, err := me.CanDoBusiGroup(rt.Ctx, bg)
-		ginx.Dangerous(err)
-
-		if !can {
-			ginx.Bomb(http.StatusForbidden, "forbidden")
-		}
-
-		c.Set("busi_group", bg)
-		c.Next()
-	}
-}
-
-// bgrw 逐步要被干掉，不安全
-func (rt *Router) Bgrw() gin.HandlerFunc {
-	return rt.bgrw()
-}
-
-func (rt *Router) bgrw() gin.HandlerFunc {
-	return func(c *gin.Context) {
-		me := c.MustGet("user").(*models.User)
-		bg := BusiGroup(rt.Ctx, ginx.UrlParamInt64(c, "id"))
-
-		can, err := me.CanDoBusiGroup(rt.Ctx, bg, "rw")
-		ginx.Dangerous(err)
-
-		if !can {
-			ginx.Bomb(http.StatusForbidden, "forbidden")
-		}
-
-		c.Set("busi_group", bg)
-		c.Next()
-	}
-}
-
-// bgrwCheck 要逐渐替换掉bgrw方法，更安全
-func (rt *Router) bgrwCheck(c *gin.Context, bgid int64) {
-	me := c.MustGet("user").(*models.User)
-	bg := BusiGroup(rt.Ctx, bgid)
-
-	can, err := me.CanDoBusiGroup(rt.Ctx, bg, "rw")
-	ginx.Dangerous(err)
-
-	if !can {
-		ginx.Bomb(http.StatusForbidden, "forbidden")
-	}
-
-	c.Set("busi_group", bg)
-}
-
-func (rt *Router) bgrwChecks(c *gin.Context, bgids []int64) {
-	set := make(map[int64]struct{})
-
-	for i := 0; i < len(bgids); i++ {
-		if _, has := set[bgids[i]]; has {
-			continue
-		}
-
-		rt.bgrwCheck(c, bgids[i])
-		set[bgids[i]] = struct{}{}
-	}
-}
-
-func (rt *Router) bgroCheck(c *gin.Context, bgid int64) {
-	me := c.MustGet("user").(*models.User)
-	bg := BusiGroup(rt.Ctx, bgid)
-
-	can, err := me.CanDoBusiGroup(rt.Ctx, bg)
-	ginx.Dangerous(err)
-
-	if !can {
-		ginx.Bomb(http.StatusForbidden, "forbidden")
-	}
-
-	c.Set("busi_group", bg)
-}
-
-func (rt *Router) Perm(operation string) gin.HandlerFunc {
-	return rt.perm(operation)
-}
-
-func (rt *Router) perm(operation string) gin.HandlerFunc {
-	return func(c *gin.Context) {
-		me := c.MustGet("user").(*models.User)
-
-		can, err := me.CheckPerm(rt.Ctx, operation)
-		ginx.Dangerous(err)
-
-		if !can {
-			ginx.Bomb(http.StatusForbidden, "forbidden")
-		}
-
-		c.Next()
-	}
-}
-
-func (rt *Router) admin() gin.HandlerFunc {
-	return func(c *gin.Context) {
-		userid := c.MustGet("userid").(int64)
-
-		user, err := models.UserGetById(rt.Ctx, userid)
-		if err != nil {
-			ginx.Bomb(http.StatusUnauthorized, "unauthorized")
-		}
-
-		if user == nil {
-			ginx.Bomb(http.StatusUnauthorized, "unauthorized")
-		}
-
-		roles := strings.Fields(user.Roles)
-		found := false
-		for i := 0; i < len(roles); i++ {
-			if roles[i] == models.AdminRole {
-				found = true
-				break
-			}
-		}
-
-		if !found {
-			ginx.Bomb(http.StatusForbidden, "forbidden")
-		}
-
-		c.Set("user", user)
-		c.Next()
-	}
-}
-
-func (rt *Router) extractTokenMetadata(r *http.Request) (*AccessDetails, error) {
-	token, err := rt.verifyToken(rt.HTTP.JWTAuth.SigningKey, rt.extractToken(r))
-	if err != nil {
-		return nil, err
-	}
-
-	claims, ok := token.Claims.(jwt.MapClaims)
-	if ok && token.Valid {
-		accessUuid, ok := claims["access_uuid"].(string)
-		if !ok {
-			return nil, errors.New("failed to parse access_uuid from jwt")
-		}
-
-		return &AccessDetails{
-			AccessUuid:   accessUuid,
-			UserIdentity: claims["user_identity"].(string),
-		}, nil
-	}
-
-	return nil, err
-}
-
-func (rt *Router) extractToken(r *http.Request) string {
-	tok := r.Header.Get("Authorization")
-
-	if len(tok) > 6 && strings.ToUpper(tok[0:7]) == "BEARER " {
-		return tok[7:]
-	}
-
-	return ""
-}
-
-func (rt *Router) createAuth(ctx context.Context, userIdentity string, td *TokenDetails) error {
-	at := time.Unix(td.AtExpires, 0)
-	rte := time.Unix(td.RtExpires, 0)
-	now := time.Now()
-
-	errAccess := rt.Redis.Set(ctx, rt.wrapJwtKey(td.AccessUuid), userIdentity, at.Sub(now)).Err()
-	if errAccess != nil {
-		return errAccess
-	}
-
-	errRefresh := rt.Redis.Set(ctx, rt.wrapJwtKey(td.RefreshUuid), userIdentity, rte.Sub(now)).Err()
-	if errRefresh != nil {
-		return errRefresh
-	}
-
-	return nil
-}
-
-func (rt *Router) fetchAuth(ctx context.Context, givenUuid string) (string, error) {
-	return rt.Redis.Get(ctx, rt.wrapJwtKey(givenUuid)).Result()
-}
-
-func (rt *Router) deleteAuth(ctx context.Context, givenUuid string) error {
-	return rt.Redis.Del(ctx, rt.wrapJwtKey(givenUuid)).Err()
-}
-
-func (rt *Router) deleteTokens(ctx context.Context, authD *AccessDetails) error {
-	// get the refresh uuid
-	refreshUuid := authD.AccessUuid + "++" + authD.UserIdentity
-
-	// delete access token
-	err := rt.Redis.Del(ctx, rt.wrapJwtKey(authD.AccessUuid)).Err()
-	if err != nil {
-		return err
-	}
-
-	// delete refresh token
-	err = rt.Redis.Del(ctx, rt.wrapJwtKey(refreshUuid)).Err()
-	if err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func (rt *Router) wrapJwtKey(key string) string {
-	return rt.HTTP.JWTAuth.RedisKeyPrefix + key
-}
-
-type TokenDetails struct {
-	AccessToken  string
-	RefreshToken string
-	AccessUuid   string
-	RefreshUuid  string
-	AtExpires    int64
-	RtExpires    int64
-}
-
-func (rt *Router) createTokens(signingKey, userIdentity string) (*TokenDetails, error) {
-	td := &TokenDetails{}
-	td.AtExpires = time.Now().Add(time.Minute * time.Duration(rt.HTTP.JWTAuth.AccessExpired)).Unix()
-	td.AccessUuid = uuid.NewString()
-
-	td.RtExpires = time.Now().Add(time.Minute * time.Duration(rt.HTTP.JWTAuth.RefreshExpired)).Unix()
-	td.RefreshUuid = td.AccessUuid + "++" + userIdentity
-
-	var err error
-	// Creating Access Token
-	atClaims := jwt.MapClaims{}
-	atClaims["authorized"] = true
-	atClaims["access_uuid"] = td.AccessUuid
-	atClaims["user_identity"] = userIdentity
-	atClaims["exp"] = td.AtExpires
-	at := jwt.NewWithClaims(jwt.SigningMethodHS256, atClaims)
-	td.AccessToken, err = at.SignedString([]byte(signingKey))
-	if err != nil {
-		return nil, err
-	}
-
-	// Creating Refresh Token
-	rtClaims := jwt.MapClaims{}
-	rtClaims["refresh_uuid"] = td.RefreshUuid
-	rtClaims["user_identity"] = userIdentity
-	rtClaims["exp"] = td.RtExpires
-	jrt := jwt.NewWithClaims(jwt.SigningMethodHS256, rtClaims)
-	td.RefreshToken, err = jrt.SignedString([]byte(signingKey))
-	if err != nil {
-		return nil, err
-	}
-
-	return td, nil
-}
-
-func (rt *Router) verifyToken(signingKey, tokenString string) (*jwt.Token, error) {
-	if tokenString == "" {
-		return nil, fmt.Errorf("bearer token not found")
-	}
-
-	token, err := jwt.Parse(tokenString, func(token *jwt.Token) (interface{}, error) {
-		if _, ok := token.Method.(*jwt.SigningMethodHMAC); !ok {
-			return nil, fmt.Errorf("unexpected jwt signing method: %v", token.Header["alg"])
-		}
-		return []byte(signingKey), nil
-	})
-	if err != nil {
-		return nil, err
-	}
-	return token, nil
-}

center/router/router_notify_config.go

@@ -1,228 +0,0 @@
-package router
-
-import (
-	"encoding/json"
-	"fmt"
-	"strings"
-
-	"github.com/ccfos/nightingale/v6/alert/aconf"
-	"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/tplx"
-
-	"github.com/gin-gonic/gin"
-	"github.com/pelletier/go-toml/v2"
-	"github.com/toolkits/pkg/ginx"
-	"github.com/toolkits/pkg/str"
-)
-
-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++ {
-		webhooks[i].Headers = []string{}
-		if len(webhooks[i].HeaderMap) > 0 {
-			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)
-	username := c.MustGet("username").(string)
-	ginx.NewRender(c).Message(models.ConfigsSetWithUname(rt.Ctx, models.WEBHOOKKEY, string(data), username))
-}
-
-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), &notifyScript)
-	ginx.NewRender(c).Data(notifyScript, err)
-}
-
-func (rt *Router) notifyScriptPut(c *gin.Context) {
-	var notifyScript models.NotifyScript
-	ginx.BindJSON(c, &notifyScript)
-
-	data, err := json.Marshal(notifyScript)
-	ginx.Dangerous(err)
-	username := c.MustGet("username").(string)
-	ginx.NewRender(c).Message(models.ConfigsSetWithUname(rt.Ctx, models.NOTIFYSCRIPT, string(data), username))
-}
-
-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), &notifyChannels)
-	ginx.NewRender(c).Data(notifyChannels, err)
-}
-
-func (rt *Router) notifyChannelPuts(c *gin.Context) {
-	var notifyChannels []models.NotifyChannel
-	ginx.BindJSON(c, &notifyChannels)
-
-	channels := []string{models.Dingtalk, models.Wecom, models.Feishu, models.Mm, models.Telegram,
-		models.Email, models.Lark, models.LarkCard}
-
-	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)
-	username := c.MustGet("username").(string)
-	ginx.NewRender(c).Message(models.ConfigsSetWithUname(rt.Ctx, models.NOTIFYCHANNEL, string(data), username))
-}
-
-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), &notifyContacts)
-	ginx.NewRender(c).Data(notifyContacts, err)
-}
-
-func (rt *Router) notifyContactPuts(c *gin.Context) {
-	var notifyContacts []models.NotifyContact
-	ginx.BindJSON(c, &notifyContacts)
-
-	keys := []string{models.DingtalkKey, models.WecomKey, models.FeishuKey, models.MmKey,
-		models.TelegramKey, models.LarkKey}
-
-	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)
-	username := c.MustGet("username").(string)
-	ginx.NewRender(c).Message(models.ConfigsSetWithUname(rt.Ctx, models.NOTIFYCONTACT, string(data), username))
-}
-
-func (rt *Router) notifyConfigGet(c *gin.Context) {
-	key := ginx.QueryStr(c, "ckey")
-	cval, err := models.ConfigsGet(rt.Ctx, key)
-	if cval == "" {
-		switch key {
-		case models.IBEX:
-			cval = memsto.DefaultIbex
-		case models.SMTP:
-			cval = memsto.DefaultSMTP
-		}
-	}
-	ginx.NewRender(c).Data(cval, err)
-}
-
-func (rt *Router) notifyConfigPut(c *gin.Context) {
-	var f models.Configs
-	ginx.BindJSON(c, &f)
-	userVariableMap := rt.NotifyConfigCache.ConfigCache.Get()
-	text := tplx.ReplaceTemplateUseText(f.Ckey, f.Cval, userVariableMap)
-	switch f.Ckey {
-	case models.SMTP:
-		var smtp aconf.SMTPConfig
-		err := toml.Unmarshal([]byte(text), &smtp)
-		ginx.Dangerous(err)
-	default:
-		ginx.Bomb(200, "key %s can not modify", f.Ckey)
-	}
-	username := c.MustGet("username").(string)
-	//insert or update build-in config
-	ginx.Dangerous(models.ConfigsSetWithUname(rt.Ctx, f.Ckey, f.Cval, username))
-	if f.Ckey == models.SMTP {
-		// 重置邮件发送器
-
-		smtp, errSmtp := SmtpValidate(text)
-		ginx.Dangerous(errSmtp)
-		go sender.RestartEmailSender(smtp)
-	}
-
-	ginx.NewRender(c).Message(nil)
-}
-func SmtpValidate(text string) (aconf.SMTPConfig, error) {
-	var smtp aconf.SMTPConfig
-	var err error
-
-	err = toml.Unmarshal([]byte(text), &smtp)
-	if err != nil {
-		return smtp, err
-	}
-	if smtp.Host == "" || smtp.Port == 0 {
-		return smtp, fmt.Errorf("smtp host or port can not be empty")
-	}
-	return smtp, err
-}
-
-type form struct {
-	models.Configs
-	Email string `json:"email"`
-}
-
-// After configuring the aconf.SMTPConfig, users can choose to perform a test. In this test, the function attempts to send an email
-func (rt *Router) attemptSendEmail(c *gin.Context) {
-	var f form
-	ginx.BindJSON(c, &f)
-
-	if f.Email = strings.TrimSpace(f.Email); f.Email == "" || !str.IsMail(f.Email) {
-		ginx.Bomb(200, "email(%s) invalid", f.Email)
-	}
-
-	if f.Ckey != models.SMTP {
-		ginx.Bomb(200, "config(%v) invalid", f)
-	}
-	userVariableMap := rt.NotifyConfigCache.ConfigCache.Get()
-	text := tplx.ReplaceTemplateUseText(f.Ckey, f.Cval, userVariableMap)
-	smtp, err := SmtpValidate(text)
-	ginx.Dangerous(err)
-
-	ginx.NewRender(c).Message(sender.SendEmail("Email test", "email content", []string{f.Email}, smtp))
-
-}

center/router/router_notify_tpl.go

@@ -1,189 +0,0 @@
-package router
-
-import (
-	"bytes"
-	"encoding/json"
-	"fmt"
-	"html/template"
-	"strings"
-	"time"
-
-	"github.com/ccfos/nightingale/v6/center/cconf"
-	"github.com/ccfos/nightingale/v6/models"
-	"github.com/ccfos/nightingale/v6/pkg/tplx"
-
-	"github.com/gin-gonic/gin"
-	"github.com/toolkits/pkg/ginx"
-	"github.com/toolkits/pkg/str"
-)
-
-func (rt *Router) notifyTplGets(c *gin.Context) {
-	m := make(map[string]struct{})
-	for _, channel := range models.DefaultChannels {
-		m[channel] = struct{}{}
-	}
-	m[models.EmailSubject] = struct{}{}
-
-	lst, err := models.NotifyTplGets(rt.Ctx)
-	for i := 0; i < len(lst); i++ {
-		if _, exists := m[lst[i].Channel]; exists {
-			lst[i].BuiltIn = true
-		}
-	}
-
-	ginx.NewRender(c).Data(lst, err)
-}
-
-func (rt *Router) notifyTplUpdateContent(c *gin.Context) {
-	user := c.MustGet("user").(*models.User)
-
-	var f models.NotifyTpl
-	ginx.BindJSON(c, &f)
-	ginx.Dangerous(templateValidate(f))
-
-	notifyTpl, err := models.NotifyTplGet(rt.Ctx, f.Id)
-	ginx.Dangerous(err)
-
-	if notifyTpl.CreateBy != user.Username && !user.IsAdmin() {
-		ginx.Bomb(403, "no permission")
-	}
-
-	f.UpdateAt = time.Now().Unix()
-	f.UpdateBy = user.Username
-
-	ginx.NewRender(c).Message(f.UpdateContent(rt.Ctx))
-}
-
-func (rt *Router) notifyTplUpdate(c *gin.Context) {
-	var f models.NotifyTpl
-	ginx.BindJSON(c, &f)
-	ginx.Dangerous(templateValidate(f))
-	user := c.MustGet("user").(*models.User)
-
-	notifyTpl, err := models.NotifyTplGet(rt.Ctx, f.Id)
-	ginx.Dangerous(err)
-
-	if notifyTpl.CreateBy != user.Username && !user.IsAdmin() {
-		ginx.Bomb(403, "no permission")
-	}
-
-	// get the count of the same channel and name but different id
-	count, err := models.Count(models.DB(rt.Ctx).Model(&models.NotifyTpl{}).Where("channel = ? or name = ? and id <> ?", f.Channel, f.Name, f.Id))
-	ginx.Dangerous(err)
-	if count != 0 {
-		ginx.Bomb(200, "Refuse to create duplicate channel or name")
-	}
-
-	notifyTpl.UpdateAt = time.Now().Unix()
-	notifyTpl.UpdateBy = user.Username
-	notifyTpl.Name = f.Name
-
-	ginx.NewRender(c).Message(notifyTpl.Update(rt.Ctx))
-}
-
-func templateValidate(f models.NotifyTpl) error {
-	if len(f.Channel) > 32 {
-		return fmt.Errorf("channel length should not exceed 32")
-	}
-
-	if str.Dangerous(f.Channel) {
-		return fmt.Errorf("channel should not contain dangerous characters")
-	}
-
-	if len(f.Name) > 255 {
-		return fmt.Errorf("name length should not exceed 255")
-	}
-
-	if str.Dangerous(f.Name) {
-		return fmt.Errorf("name should not contain dangerous characters")
-	}
-
-	if f.Content == "" {
-		return nil
-	}
-
-	var defs = []string{
-		"{{$labels := .TagsMap}}",
-		"{{$value := .TriggerValue}}",
-	}
-	text := strings.Join(append(defs, f.Content), "")
-
-	if _, err := template.New(f.Channel).Funcs(tplx.TemplateFuncMap).Parse(text); err != nil {
-		return fmt.Errorf("notify template verify illegal:%s", err.Error())
-	}
-
-	return nil
-}
-
-func (rt *Router) notifyTplPreview(c *gin.Context) {
-	var event models.AlertCurEvent
-	err := json.Unmarshal([]byte(cconf.EVENT_EXAMPLE), &event)
-	ginx.Dangerous(err)
-
-	var f models.NotifyTpl
-	ginx.BindJSON(c, &f)
-
-	var defs = []string{
-		"{{$labels := .TagsMap}}",
-		"{{$value := .TriggerValue}}",
-	}
-	text := strings.Join(append(defs, f.Content), "")
-	tpl, err := template.New(f.Channel).Funcs(tplx.TemplateFuncMap).Parse(text)
-	ginx.Dangerous(err)
-
-	event.TagsMap = make(map[string]string)
-	for i := 0; i < len(event.TagsJSON); i++ {
-		pair := strings.TrimSpace(event.TagsJSON[i])
-		if pair == "" {
-			continue
-		}
-
-		arr := strings.Split(pair, "=")
-		if len(arr) != 2 {
-			continue
-		}
-
-		event.TagsMap[arr[0]] = arr[1]
-	}
-
-	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)
-}
-
-// add new notify template
-func (rt *Router) notifyTplAdd(c *gin.Context) {
-	var f models.NotifyTpl
-	ginx.BindJSON(c, &f)
-	f.Channel = strings.TrimSpace(f.Channel)
-	ginx.Dangerous(templateValidate(f))
-
-	count, err := models.Count(models.DB(rt.Ctx).Model(&models.NotifyTpl{}).Where("channel = ? or name = ?", f.Channel, f.Name))
-	ginx.Dangerous(err)
-	if count != 0 {
-		ginx.Bomb(200, "Refuse to create duplicate channel(unique)")
-	}
-	ginx.NewRender(c).Message(f.Create(rt.Ctx))
-}
-
-// delete notify template, not allowed to delete the system defaults(models.DefaultChannels)
-func (rt *Router) notifyTplDel(c *gin.Context) {
-	f := new(models.NotifyTpl)
-	id := ginx.UrlParamInt64(c, "id")
-	user := c.MustGet("user").(*models.User)
-
-	notifyTpl, err := models.NotifyTplGet(rt.Ctx, id)
-	ginx.Dangerous(err)
-
-	if notifyTpl.CreateBy != user.Username && !user.IsAdmin() {
-		ginx.Bomb(403, "no permission")
-	}
-
-	ginx.NewRender(c).Message(f.NotifyTplDelete(rt.Ctx, id))
-}

center/router/router_proxy.go

@@ -1,238 +0,0 @@
-package router
-
-import (
-	"context"
-	"crypto/tls"
-	"fmt"
-	"net"
-	"net/http"
-	"net/http/httputil"
-	"net/url"
-	"strings"
-	"sync"
-	"time"
-
-	pkgprom "github.com/ccfos/nightingale/v6/pkg/prom"
-	"github.com/ccfos/nightingale/v6/prom"
-	"github.com/gin-gonic/gin"
-	"github.com/prometheus/common/model"
-	"github.com/toolkits/pkg/ginx"
-	"github.com/toolkits/pkg/logger"
-)
-
-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))
-
-	lst, err := PromBatchQueryRange(rt.PromClients, f)
-	ginx.NewRender(c).Data(lst, err)
-}
-
-func PromBatchQueryRange(pc *prom.PromClientMap, f BatchQueryForm) ([]model.Value, error) {
-	var lst []model.Value
-
-	cli := pc.GetCli(f.DatasourceId)
-	if cli == nil {
-		return lst, fmt.Errorf("no such datasource id: %d", f.DatasourceId)
-	}
-
-	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)
-		if err != nil {
-			return lst, err
-		}
-
-		lst = append(lst, resp)
-	}
-	return lst, nil
-}
-
-type BatchInstantForm struct {
-	DatasourceId int64             `json:"datasource_id" binding:"required"`
-	Queries      []InstantFormItem `json:"queries" binding:"required"`
-}
-
-type InstantFormItem struct {
-	Time  int64  `json:"time" binding:"required"`
-	Query string `json:"query" binding:"required"`
-}
-
-func (rt *Router) promBatchQueryInstant(c *gin.Context) {
-	var f BatchInstantForm
-	ginx.Dangerous(c.BindJSON(&f))
-
-	lst, err := PromBatchQueryInstant(rt.PromClients, f)
-	ginx.NewRender(c).Data(lst, err)
-}
-
-func PromBatchQueryInstant(pc *prom.PromClientMap, f BatchInstantForm) ([]model.Value, error) {
-	var lst []model.Value
-
-	cli := pc.GetCli(f.DatasourceId)
-	if cli == nil {
-		logger.Warningf("no such datasource id: %d", f.DatasourceId)
-		return lst, fmt.Errorf("no such datasource id: %d", f.DatasourceId)
-	}
-
-	for _, item := range f.Queries {
-		resp, _, err := cli.Query(context.Background(), item.Query, time.Unix(item.Time, 0))
-		if err != nil {
-			return lst, err
-		}
-
-		lst = append(lst, resp)
-	}
-	return lst, nil
-}
-
-func (rt *Router) dsProxy(c *gin.Context) {
-	dsId := ginx.UrlParamInt64(c, "id")
-	ds := rt.DatasourceCache.GetById(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, has := transportGet(dsId, ds.UpdatedAt)
-	if !has {
-		transport = &http.Transport{
-			TLSClientConfig: &tls.Config{InsecureSkipVerify: ds.HTTPJson.TLS.SkipTlsVerify},
-			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,
-		}
-		transportPut(dsId, ds.UpdatedAt, transport)
-	}
-
-	modifyResponse := func(r *http.Response) error {
-		if r.StatusCode == http.StatusUnauthorized {
-			logger.Warningf("proxy path:%s unauthorized access ", c.Request.URL.Path)
-			return fmt.Errorf("unauthorized access")
-		}
-
-		return nil
-	}
-
-	proxy := &httputil.ReverseProxy{
-		Director:       director,
-		Transport:      transport,
-		ErrorHandler:   errFunc,
-		ModifyResponse: modifyResponse,
-	}
-
-	proxy.ServeHTTP(c.Writer, c.Request)
-
-}
-
-var (
-	transports     = map[int64]http.RoundTripper{}
-	updatedAts     = map[int64]int64{}
-	transportsLock = &sync.Mutex{}
-)
-
-func transportGet(dsid, newUpdatedAt int64) (http.RoundTripper, bool) {
-	transportsLock.Lock()
-	defer transportsLock.Unlock()
-
-	tran, has := transports[dsid]
-	if !has {
-		return nil, false
-	}
-
-	oldUpdateAt, has := updatedAts[dsid]
-	if !has {
-		oldtran := tran.(*http.Transport)
-		oldtran.CloseIdleConnections()
-		delete(transports, dsid)
-		return nil, false
-	}
-
-	if oldUpdateAt != newUpdatedAt {
-		oldtran := tran.(*http.Transport)
-		oldtran.CloseIdleConnections()
-		delete(transports, dsid)
-		delete(updatedAts, dsid)
-		return nil, false
-	}
-
-	return tran, has
-}
-
-func transportPut(dsid, updatedat int64, tran http.RoundTripper) {
-	transportsLock.Lock()
-	transports[dsid] = tran
-	updatedAts[dsid] = updatedat
-	transportsLock.Unlock()
-}

center/router/router_recording_rule.go

@@ -1,171 +0,0 @@
-package router
-
-import (
-	"encoding/json"
-	"net/http"
-	"strconv"
-	"strings"
-	"time"
-
-	"github.com/ccfos/nightingale/v6/models"
-
-	"github.com/gin-gonic/gin"
-	"github.com/toolkits/pkg/ginx"
-	"github.com/toolkits/pkg/str"
-)
-
-func (rt *Router) recordingRuleGets(c *gin.Context) {
-	busiGroupId := ginx.UrlParamInt64(c, "id")
-	ars, err := models.RecordingRuleGets(rt.Ctx, busiGroupId)
-	ginx.NewRender(c).Data(ars, err)
-}
-
-func (rt *Router) recordingRuleGetsByGids(c *gin.Context) {
-	gids := str.IdsInt64(ginx.QueryStr(c, "gids", ""), ",")
-	if len(gids) > 0 {
-		for _, gid := range gids {
-			rt.bgroCheck(c, gid)
-		}
-	} else {
-		me := c.MustGet("user").(*models.User)
-		if !me.IsAdmin() {
-			var err error
-			gids, err = models.MyBusiGroupIds(rt.Ctx, me.Id)
-			ginx.Dangerous(err)
-
-			if len(gids) == 0 {
-				ginx.NewRender(c).Data([]int{}, nil)
-				return
-			}
-		}
-	}
-
-	ars, err := models.RecordingRuleGetsByBGIds(rt.Ctx, gids)
-	ginx.NewRender(c).Data(ars, err)
-}
-
-func (rt *Router) recordingRuleGetsByService(c *gin.Context) {
-	ars, err := models.RecordingRuleEnabledGets(rt.Ctx)
-	ginx.NewRender(c).Data(ars, err)
-}
-
-func (rt *Router) recordingRuleGet(c *gin.Context) {
-	rrid := ginx.UrlParamInt64(c, "rrid")
-
-	ar, err := models.RecordingRuleGetById(rt.Ctx, rrid)
-	ginx.Dangerous(err)
-
-	if ar == nil {
-		ginx.NewRender(c, http.StatusNotFound).Message("No such recording rule")
-		return
-	}
-
-	ginx.NewRender(c).Data(ar, err)
-}
-
-func (rt *Router) recordingRuleAddByFE(c *gin.Context) {
-	username := c.MustGet("username").(string)
-
-	var lst []models.RecordingRule
-	ginx.BindJSON(c, &lst)
-
-	count := len(lst)
-	if count == 0 {
-		ginx.Bomb(http.StatusBadRequest, "input json is empty")
-	}
-
-	bgid := ginx.UrlParamInt64(c, "id")
-	reterr := make(map[string]string)
-	for i := 0; i < count; i++ {
-		lst[i].Id = 0
-		lst[i].GroupId = bgid
-		lst[i].CreateBy = username
-		lst[i].UpdateBy = username
-		lst[i].FE2DB()
-
-		if err := lst[i].Add(rt.Ctx); err != nil {
-			reterr[lst[i].Name] = err.Error()
-		} else {
-			reterr[lst[i].Name] = ""
-		}
-	}
-	ginx.NewRender(c).Data(reterr, nil)
-}
-
-func (rt *Router) recordingRulePutByFE(c *gin.Context) {
-	var f models.RecordingRule
-	ginx.BindJSON(c, &f)
-
-	rrid := ginx.UrlParamInt64(c, "rrid")
-	ar, err := models.RecordingRuleGetById(rt.Ctx, rrid)
-	ginx.Dangerous(err)
-
-	if ar == nil {
-		ginx.NewRender(c, http.StatusNotFound).Message("No such recording rule")
-		return
-	}
-
-	rt.bgrwCheck(c, ar.GroupId)
-
-	f.UpdateBy = c.MustGet("username").(string)
-	ginx.NewRender(c).Message(ar.Update(rt.Ctx, f))
-
-}
-
-func (rt *Router) recordingRuleDel(c *gin.Context) {
-	var f idsForm
-	ginx.BindJSON(c, &f)
-	f.Verify()
-
-	ginx.NewRender(c).Message(models.RecordingRuleDels(rt.Ctx, f.Ids, ginx.UrlParamInt64(c, "id")))
-
-}
-
-type recordRuleFieldForm struct {
-	Ids    []int64                `json:"ids"`
-	Fields map[string]interface{} `json:"fields"`
-}
-
-func (rt *Router) recordingRulePutFields(c *gin.Context) {
-	var f recordRuleFieldForm
-	ginx.BindJSON(c, &f)
-
-	if len(f.Fields) == 0 {
-		ginx.Bomb(http.StatusBadRequest, "fields empty")
-	}
-
-	f.Fields["update_by"] = c.MustGet("username").(string)
-	f.Fields["update_at"] = time.Now().Unix()
-
-	if _, ok := f.Fields["datasource_ids"]; ok {
-		// datasource_ids = "1 2 3"
-		idsStr := strings.Fields(f.Fields["datasource_ids"].(string))
-		ids := make([]int64, 0)
-		for _, idStr := range idsStr {
-			id, err := strconv.ParseInt(idStr, 10, 64)
-			if err != nil {
-				ginx.Bomb(http.StatusBadRequest, "datasource_ids error")
-			}
-			ids = append(ids, id)
-		}
-
-		bs, err := json.Marshal(ids)
-		if err != nil {
-			ginx.Bomb(http.StatusBadRequest, "datasource_ids error")
-		}
-		f.Fields["datasource_ids"] = string(bs)
-	}
-
-	for i := 0; i < len(f.Ids); i++ {
-		ar, err := models.RecordingRuleGetById(rt.Ctx, f.Ids[i])
-		ginx.Dangerous(err)
-
-		if ar == nil {
-			continue
-		}
-
-		ginx.Dangerous(ar.UpdateFieldsMap(rt.Ctx, f.Fields))
-	}
-
-	ginx.NewRender(c).Message(nil)
-}

center/router/router_role.go

@@ -1,110 +0,0 @@
-package router
-
-import (
-	"net/http"
-	"strings"
-
-	"github.com/ccfos/nightingale/v6/center/cconf"
-	"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)
-	if user.IsAdmin() {
-		var lst []string
-		for _, ops := range cconf.Operations.Ops {
-			lst = append(lst, ops.Ops...)
-		}
-		ginx.NewRender(c).Data(lst, nil)
-		return
-	}
-
-	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)
-}
-
-func (rt *Router) allPerms(c *gin.Context) {
-	roles, err := models.RoleGetsAll(rt.Ctx)
-	ginx.Dangerous(err)
-	m := make(map[string][]string)
-	for _, r := range roles {
-		lst, err := models.OperationsOfRole(rt.Ctx, strings.Fields(r.Name))
-		if err != nil {
-			continue
-		}
-		m[r.Name] = lst
-	}
-
-	ginx.NewRender(c).Data(m, err)
-}

center/router/router_role_operation.go

@@ -1,60 +0,0 @@
-package router
-
-import (
-	"net/http"
-
-	"github.com/ccfos/nightingale/v6/center/cconf"
-	"github.com/ccfos/nightingale/v6/models"
-	"github.com/gin-gonic/gin"
-	"github.com/toolkits/pkg/ginx"
-	"github.com/toolkits/pkg/i18n"
-)
-
-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")
-	}
-
-	if role.Name == "Admin" {
-		var lst []string
-		for _, ops := range cconf.Operations.Ops {
-			lst = append(lst, ops.Ops...)
-		}
-		ginx.NewRender(c).Data(lst, nil)
-		return
-	}
-
-	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) {
-	var ops []cconf.Ops
-	for _, v := range rt.Operations.Ops {
-		v.Cname = i18n.Sprintf(c.GetHeader("X-Language"), v.Cname)
-		ops = append(ops, v)
-	}
-
-	ginx.NewRender(c).Data(ops, nil)
-}

center/router/router_self.go

@@ -1,84 +0,0 @@
-package router
-
-import (
-	"github.com/ccfos/nightingale/v6/models"
-	"github.com/ccfos/nightingale/v6/pkg/flashduty"
-	"github.com/ccfos/nightingale/v6/pkg/ormx"
-	"github.com/ccfos/nightingale/v6/pkg/secu"
-
-	"github.com/gin-gonic/gin"
-	"github.com/toolkits/pkg/ginx"
-	"github.com/toolkits/pkg/logger"
-)
-
-func (rt *Router) selfProfileGet(c *gin.Context) {
-	user := c.MustGet("user").(*models.User)
-	if user.IsAdmin() {
-		user.Admin = true
-	}
-	ginx.NewRender(c).Data(user, nil)
-}
-
-type selfProfileForm struct {
-	Nickname string       `json:"nickname"`
-	Phone    string       `json:"phone"`
-	Email    string       `json:"email"`
-	Portrait string       `json:"portrait"`
-	Contacts ormx.JSONObj `json:"contacts"`
-}
-
-func (rt *Router) selfProfilePut(c *gin.Context) {
-	var f selfProfileForm
-	ginx.BindJSON(c, &f)
-
-	user := c.MustGet("user").(*models.User)
-	oldInfo := models.User{
-		Username: user.Username,
-		Phone:    user.Phone,
-		Email:    user.Email,
-	}
-	user.Nickname = f.Nickname
-	user.Phone = f.Phone
-	user.Email = f.Email
-	user.Portrait = f.Portrait
-	user.Contacts = f.Contacts
-	user.UpdateBy = user.Username
-
-	if flashduty.NeedSyncUser(rt.Ctx) {
-		flashduty.UpdateUser(rt.Ctx, oldInfo, f.Email, f.Phone)
-	}
-
-	ginx.NewRender(c).Message(user.UpdateAllFields(rt.Ctx))
-}
-
-type selfPasswordForm struct {
-	OldPass string `json:"oldpass" binding:"required"`
-	NewPass string `json:"newpass" binding:"required"`
-}
-
-func (rt *Router) selfPasswordPut(c *gin.Context) {
-	var f selfPasswordForm
-	ginx.BindJSON(c, &f)
-	user := c.MustGet("user").(*models.User)
-
-	newPassWord := f.NewPass
-	oldPassWord := f.OldPass
-	if rt.HTTP.RSA.OpenRSA {
-		var err error
-		newPassWord, err = secu.Decrypt(f.NewPass, rt.HTTP.RSA.RSAPrivateKey, rt.HTTP.RSA.RSAPassWord)
-		if err != nil {
-			logger.Errorf("RSA Decrypt failed: %v username: %s", err, user.Username)
-			ginx.NewRender(c).Message(err)
-			return
-		}
-
-		oldPassWord, err = secu.Decrypt(f.OldPass, rt.HTTP.RSA.RSAPrivateKey, rt.HTTP.RSA.RSAPassWord)
-		if err != nil {
-			logger.Errorf("RSA Decrypt failed: %v username: %s", err, user.Username)
-			ginx.NewRender(c).Message(err)
-			return
-		}
-	}
-
-	ginx.NewRender(c).Message(user.ChangePassword(rt.Ctx, oldPassWord, newPassWord))
-}

center/router/router_server.go

@@ -1,44 +0,0 @@
-package router
-
-import (
-	"time"
-
-	"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)
-}
-
-func (rt *Router) serverHeartbeat(c *gin.Context) {
-	var req models.HeartbeatInfo
-	ginx.BindJSON(c, &req)
-	err := models.AlertingEngineHeartbeatWithCluster(rt.Ctx, req.Instance, req.EngineCluster, req.DatasourceId)
-	ginx.NewRender(c).Message(err)
-}
-
-func (rt *Router) serversActive(c *gin.Context) {
-	datasourceId := ginx.QueryInt64(c, "dsid", 0)
-	engineName := ginx.QueryStr(c, "engine_name", "")
-	if engineName != "" {
-		servers, err := models.AlertingEngineGetsInstances(rt.Ctx, "engine_cluster = ? and clock > ?", engineName, time.Now().Unix()-30)
-		ginx.NewRender(c).Data(servers, err)
-		return
-	}
-
-	if datasourceId == 0 {
-		ginx.NewRender(c).Message("dsid is required")
-		return
-	}
-	servers, err := models.AlertingEngineGetsInstances(rt.Ctx, "datasource_id = ? and clock > ?", datasourceId, time.Now().Unix()-30)
-	ginx.NewRender(c).Data(servers, err)
-}

center/router/router_target.go

@@ -1,533 +0,0 @@
-package router
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-	"net/http"
-	"strings"
-	"time"
-
-	"github.com/ccfos/nightingale/v6/models"
-	"github.com/ccfos/nightingale/v6/storage"
-
-	"github.com/gin-gonic/gin"
-	"github.com/prometheus/common/model"
-	"github.com/toolkits/pkg/ginx"
-	"github.com/toolkits/pkg/logger"
-	"github.com/toolkits/pkg/str"
-)
-
-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, f.Limit, (f.P-1)*f.Limit)
-	ginx.Dangerous(err)
-
-	total, err := models.TargetCountByFilter(rt.Ctx, query)
-	ginx.Dangerous(err)
-
-	ginx.NewRender(c).Data(gin.H{
-		"list":  hosts,
-		"total": total,
-	}, nil)
-}
-
-func (rt *Router) targetGets(c *gin.Context) {
-	bgids := str.IdsInt64(ginx.QueryStr(c, "gids", ""), ",")
-	query := ginx.QueryStr(c, "query", "")
-	limit := ginx.QueryInt(c, "limit", 30)
-	downtime := ginx.QueryInt64(c, "downtime", 0)
-	dsIds := queryDatasourceIds(c)
-
-	order := ginx.QueryStr(c, "order", "ident")
-	desc := ginx.QueryBool(c, "desc", false)
-
-	var err error
-	if len(bgids) == 0 {
-		user := c.MustGet("user").(*models.User)
-		if !user.IsAdmin() {
-			// 如果是非 admin 用户，全部对象的情况，找到用户有权限的业务组
-			var err error
-			bgids, err = models.MyBusiGroupIds(rt.Ctx, user.Id)
-			ginx.Dangerous(err)
-
-			// 将未分配业务组的对象也加入到列表中
-			bgids = append(bgids, 0)
-		}
-	}
-	options := []models.BuildTargetWhereOption{
-		models.BuildTargetWhereWithBgids(bgids),
-		models.BuildTargetWhereWithDsIds(dsIds),
-		models.BuildTargetWhereWithQuery(query),
-		models.BuildTargetWhereWithDowntime(downtime),
-	}
-	total, err := models.TargetTotal(rt.Ctx, options...)
-	ginx.Dangerous(err)
-
-	list, err := models.TargetGets(rt.Ctx, limit,
-		ginx.Offset(c, limit), order, desc, options...)
-	ginx.Dangerous(err)
-
-	if err == nil {
-		now := time.Now()
-		cache := make(map[int64]*models.BusiGroup)
-
-		var keys []string
-		for i := 0; i < len(list); i++ {
-			ginx.Dangerous(list[i].FillGroup(rt.Ctx, cache))
-			keys = append(keys, models.WrapIdent(list[i].Ident))
-
-			if now.Unix()-list[i].UpdateAt < 60 {
-				list[i].TargetUp = 2
-			} else if now.Unix()-list[i].UpdateAt < 180 {
-				list[i].TargetUp = 1
-			}
-		}
-
-		if len(keys) > 0 {
-			metaMap := make(map[string]*models.HostMeta)
-			vals := storage.MGet(context.Background(), rt.Redis, keys)
-			for _, value := range vals {
-				var meta models.HostMeta
-				if value == nil {
-					continue
-				}
-				err := json.Unmarshal(value, &meta)
-				if err != nil {
-					logger.Warningf("unmarshal %v host meta failed: %v", value, err)
-					continue
-				}
-				metaMap[meta.Hostname] = &meta
-			}
-
-			for i := 0; i < len(list); i++ {
-				if meta, ok := metaMap[list[i].Ident]; ok {
-					list[i].FillMeta(meta)
-				} else {
-					// 未上报过元数据的主机，cpuNum默认为-1, 用于前端展示 unknown
-					list[i].CpuNum = -1
-				}
-			}
-		}
-
-	}
-
-	ginx.NewRender(c).Data(gin.H{
-		"list":  list,
-		"total": total,
-	}, nil)
-}
-
-func (rt *Router) targetExtendInfoByIdent(c *gin.Context) {
-	ident := ginx.QueryStr(c, "ident", "")
-	key := models.WrapExtendIdent(ident)
-	vals := storage.MGet(context.Background(), rt.Redis, []string{key})
-	if len(vals) > 0 {
-		extInfo := string(vals[0])
-		if extInfo == "null" {
-			extInfo = ""
-		}
-		ginx.NewRender(c).Data(gin.H{
-			"extend_info": extInfo,
-			"ident":       ident,
-		}, nil)
-		return
-	}
-	ginx.NewRender(c).Data(gin.H{
-		"extend_info": "",
-		"ident":       ident,
-	}, nil)
-}
-
-func (rt *Router) targetGetsByService(c *gin.Context) {
-	lst, err := models.TargetGetsAll(rt.Ctx)
-	ginx.NewRender(c).Data(lst, err)
-}
-
-func (rt *Router) targetGetTags(c *gin.Context) {
-	idents := ginx.QueryStr(c, "idents", "")
-	idents = strings.ReplaceAll(idents, ",", " ")
-	lst, err := models.TargetGetTags(rt.Ctx, strings.Fields(idents))
-	ginx.NewRender(c).Data(lst, err)
-}
-
-type targetTagsForm struct {
-	Idents  []string `json:"idents" binding:"required_without=HostIps"`
-	HostIps []string `json:"host_ips" binding:"required_without=Idents"`
-	Tags    []string `json:"tags" binding:"required"`
-}
-
-func (rt *Router) targetBindTagsByFE(c *gin.Context) {
-	var f targetTagsForm
-	var err error
-	var failedResults = make(map[string]string)
-	ginx.BindJSON(c, &f)
-
-	if len(f.Idents) == 0 && len(f.HostIps) == 0 {
-		ginx.Bomb(http.StatusBadRequest, "idents or host_ips must be provided")
-	}
-	// Acquire idents by idents and hostIps
-	failedResults, f.Idents, err = models.TargetsGetIdentsByIdentsAndHostIps(rt.Ctx, f.Idents, f.HostIps)
-	if err != nil {
-		ginx.Bomb(http.StatusBadRequest, err.Error())
-	}
-
-	rt.checkTargetPerm(c, f.Idents)
-
-	ginx.NewRender(c).Data(rt.targetBindTags(f, failedResults))
-}
-
-func (rt *Router) targetBindTagsByService(c *gin.Context) {
-	var f targetTagsForm
-	var err error
-	var failedResults = make(map[string]string)
-	ginx.BindJSON(c, &f)
-
-	if len(f.Idents) == 0 && len(f.HostIps) == 0 {
-		ginx.Bomb(http.StatusBadRequest, "idents or host_ips must be provided")
-	}
-	// Acquire idents by idents and hostIps
-	failedResults, f.Idents, err = models.TargetsGetIdentsByIdentsAndHostIps(rt.Ctx, f.Idents, f.HostIps)
-	if err != nil {
-		ginx.Bomb(http.StatusBadRequest, err.Error())
-	}
-
-	ginx.NewRender(c).Data(rt.targetBindTags(f, failedResults))
-}
-
-func (rt *Router) targetBindTags(f targetTagsForm, failedIdents map[string]string) (map[string]string, error) {
-	// 1. Check tags
-	if err := rt.validateTags(f.Tags); err != nil {
-		return nil, err
-	}
-
-	// 2. Acquire targets by idents
-	targets, err := models.TargetsGetByIdents(rt.Ctx, f.Idents)
-	if err != nil {
-		return nil, err
-	}
-
-	// 3. Add tags to targets
-	for _, target := range targets {
-		if err = rt.addTagsToTarget(target, f.Tags); err != nil {
-			failedIdents[target.Ident] = err.Error()
-		}
-	}
-
-	return failedIdents, nil
-}
-
-func (rt *Router) validateTags(tags []string) error {
-	for _, tag := range tags {
-		arr := strings.Split(tag, "=")
-		if len(arr) != 2 {
-			return fmt.Errorf("invalid tag format: %s (expected format: key=value)", tag)
-		}
-
-		key, value := strings.TrimSpace(arr[0]), strings.TrimSpace(arr[1])
-		if key == "" {
-			return fmt.Errorf("invalid tag: key is empty in tag %s", tag)
-		}
-		if value == "" {
-			return fmt.Errorf("invalid tag: value is empty in tag %s", tag)
-		}
-
-		if strings.Contains(key, ".") {
-			return fmt.Errorf("invalid tag key: %s (key cannot contain '.')", key)
-		}
-
-		if strings.Contains(key, "-") {
-			return fmt.Errorf("invalid tag key: %s (key cannot contain '-')", key)
-		}
-
-		if !model.LabelNameRE.MatchString(key) {
-			return fmt.Errorf("invalid tag key: %s "+
-				"(key must start with a letter or underscore, followed by letters, digits, or underscores)", key)
-		}
-	}
-
-	return nil
-}
-
-func (rt *Router) addTagsToTarget(target *models.Target, tags []string) error {
-	for _, tag := range tags {
-		tagKey := strings.Split(tag, "=")[0]
-		if strings.Contains(target.Tags, tagKey+"=") {
-			return fmt.Errorf("duplicate tagkey(%s)", tagKey)
-		}
-	}
-
-	return target.AddTags(rt.Ctx, tags)
-}
-
-func (rt *Router) targetUnbindTagsByFE(c *gin.Context) {
-	var f targetTagsForm
-	var err error
-	var failedResults = make(map[string]string)
-	ginx.BindJSON(c, &f)
-
-	if len(f.Idents) == 0 && len(f.HostIps) == 0 {
-		ginx.Bomb(http.StatusBadRequest, "idents or host_ips must be provided")
-	}
-	// Acquire idents by idents and hostIps
-	failedResults, f.Idents, err = models.TargetsGetIdentsByIdentsAndHostIps(rt.Ctx, f.Idents, f.HostIps)
-	if err != nil {
-		ginx.Bomb(http.StatusBadRequest, err.Error())
-	}
-
-	rt.checkTargetPerm(c, f.Idents)
-
-	ginx.NewRender(c).Data(rt.targetUnbindTags(f, failedResults))
-}
-
-func (rt *Router) targetUnbindTagsByService(c *gin.Context) {
-	var f targetTagsForm
-	var err error
-	var failedResults = make(map[string]string)
-	ginx.BindJSON(c, &f)
-
-	if len(f.Idents) == 0 && len(f.HostIps) == 0 {
-		ginx.Bomb(http.StatusBadRequest, "idents or host_ips must be provided")
-	}
-	// Acquire idents by idents and hostIps
-	failedResults, f.Idents, err = models.TargetsGetIdentsByIdentsAndHostIps(rt.Ctx, f.Idents, f.HostIps)
-	if err != nil {
-		ginx.Bomb(http.StatusBadRequest, err.Error())
-	}
-
-	ginx.NewRender(c).Data(rt.targetUnbindTags(f, failedResults))
-}
-
-func (rt *Router) targetUnbindTags(f targetTagsForm, failedIdents map[string]string) (map[string]string, error) {
-	// 1. Acquire targets by idents
-	targets, err := models.TargetsGetByIdents(rt.Ctx, f.Idents)
-	if err != nil {
-		return nil, err
-	}
-
-	// 2. Remove tags from targets
-	for _, target := range targets {
-		err = target.DelTags(rt.Ctx, f.Tags)
-		if err != nil {
-			failedIdents[target.Ident] = err.Error()
-			continue
-		}
-	}
-
-	return failedIdents, nil
-}
-
-type targetNoteForm struct {
-	Idents  []string `json:"idents" binding:"required_without=HostIps"`
-	HostIps []string `json:"host_ips" binding:"required_without=Idents"`
-	Note    string   `json:"note"`
-}
-
-func (rt *Router) targetUpdateNote(c *gin.Context) {
-	var f targetNoteForm
-	var err error
-	var failedResults = make(map[string]string)
-	ginx.BindJSON(c, &f)
-
-	if len(f.Idents) == 0 && len(f.HostIps) == 0 {
-		ginx.Bomb(http.StatusBadRequest, "idents or host_ips must be provided")
-	}
-
-	// Acquire idents by idents and hostIps
-	failedResults, f.Idents, err = models.TargetsGetIdentsByIdentsAndHostIps(rt.Ctx, f.Idents, f.HostIps)
-	if err != nil {
-		ginx.Bomb(http.StatusBadRequest, err.Error())
-	}
-
-	rt.checkTargetPerm(c, f.Idents)
-
-	ginx.NewRender(c).Data(failedResults, models.TargetUpdateNote(rt.Ctx, f.Idents, f.Note))
-}
-
-func (rt *Router) targetUpdateNoteByService(c *gin.Context) {
-	var f targetNoteForm
-	var err error
-	var failedResults = make(map[string]string)
-	ginx.BindJSON(c, &f)
-
-	if len(f.Idents) == 0 && len(f.HostIps) == 0 {
-		ginx.Bomb(http.StatusBadRequest, "idents or host_ips must be provided")
-	}
-
-	// Acquire idents by idents and hostIps
-	failedResults, f.Idents, err = models.TargetsGetIdentsByIdentsAndHostIps(rt.Ctx, f.Idents, f.HostIps)
-	if err != nil {
-		ginx.Bomb(http.StatusBadRequest, err.Error())
-	}
-
-	ginx.NewRender(c).Data(failedResults, models.TargetUpdateNote(rt.Ctx, f.Idents, f.Note))
-}
-
-type targetBgidForm struct {
-	Idents  []string `json:"idents" binding:"required_without=HostIps"`
-	HostIps []string `json:"host_ips" binding:"required_without=Idents"`
-	Bgid    int64    `json:"bgid"`
-}
-
-func (rt *Router) targetUpdateBgid(c *gin.Context) {
-	var f targetBgidForm
-	var err error
-	var failedResults = make(map[string]string)
-	ginx.BindJSON(c, &f)
-
-	if len(f.Idents) == 0 && len(f.HostIps) == 0 {
-		ginx.Bomb(http.StatusBadRequest, "idents or host_ips must be provided")
-	}
-
-	// Acquire idents by idents and hostIps
-	failedResults, f.Idents, err = models.TargetsGetIdentsByIdentsAndHostIps(rt.Ctx, f.Idents, f.HostIps)
-	if err != nil {
-		ginx.Bomb(http.StatusBadRequest, err.Error())
-	}
-
-	user := c.MustGet("user").(*models.User)
-	if user.IsAdmin() {
-		ginx.NewRender(c).Data(failedResults, models.TargetUpdateBgid(rt.Ctx, f.Idents, f.Bgid, false))
-		return
-	}
-
-	if f.Bgid > 0 {
-		// 把要操作的机器分成两部分，一部分是bgid为0，需要管理员分配，另一部分bgid>0，说明是业务组内部想调整
-		// 比如原来分配给didiyun的机器，didiyun的管理员想把部分机器调整到didiyun-ceph下
-		// 对于调整的这种情况，当前登录用户要对这批机器有操作权限，同时还要对目标BG有操作权限
-		orphans, err := models.IdentsFilter(rt.Ctx, f.Idents, "group_id = ?", 0)
-		ginx.Dangerous(err)
-
-		// 机器里边存在未归组的，登录用户就需要是admin
-		if len(orphans) > 0 && !user.IsAdmin() {
-			can, err := user.CheckPerm(rt.Ctx, "/targets/bind")
-			ginx.Dangerous(err)
-			if !can {
-				ginx.Bomb(http.StatusForbidden, "No permission. Only admin can assign BG")
-			}
-		}
-
-		reBelongs, err := models.IdentsFilter(rt.Ctx, f.Idents, "group_id > ?", 0)
-		ginx.Dangerous(err)
-
-		if len(reBelongs) > 0 {
-			// 对于这些要重新分配的机器，操作者要对这些机器本身有权限，同时要对目标bgid有权限
-			rt.checkTargetPerm(c, f.Idents)
-
-			bg := BusiGroup(rt.Ctx, f.Bgid)
-			can, err := user.CanDoBusiGroup(rt.Ctx, bg, "rw")
-			ginx.Dangerous(err)
-
-			if !can {
-				ginx.Bomb(http.StatusForbidden, "No permission. You are not admin of BG(%s)", bg.Name)
-			}
-		}
-	} else if f.Bgid == 0 {
-		// 退还机器
-		rt.checkTargetPerm(c, f.Idents)
-	} else {
-		ginx.Bomb(http.StatusBadRequest, "invalid bgid")
-	}
-
-	ginx.NewRender(c).Data(failedResults, models.TargetUpdateBgid(rt.Ctx, f.Idents, f.Bgid, false))
-}
-
-func (rt *Router) targetUpdateBgidByService(c *gin.Context) {
-	var f targetBgidForm
-	var err error
-	var failedResults = make(map[string]string)
-	ginx.BindJSON(c, &f)
-
-	if len(f.Idents) == 0 && len(f.HostIps) == 0 {
-		ginx.Bomb(http.StatusBadRequest, "idents or host_ips must be provided")
-	}
-
-	// Acquire idents by idents and hostIps
-	failedResults, f.Idents, err = models.TargetsGetIdentsByIdentsAndHostIps(rt.Ctx, f.Idents, f.HostIps)
-	if err != nil {
-		ginx.Bomb(http.StatusBadRequest, err.Error())
-	}
-
-	ginx.NewRender(c).Data(failedResults, models.TargetUpdateBgid(rt.Ctx, f.Idents, f.Bgid, false))
-}
-
-type identsForm struct {
-	Idents  []string `json:"idents" binding:"required_without=HostIps"`
-	HostIps []string `json:"host_ips" binding:"required_without=Idents"`
-}
-
-func (rt *Router) targetDel(c *gin.Context) {
-	var f identsForm
-	var err error
-	var failedResults = make(map[string]string)
-	ginx.BindJSON(c, &f)
-
-	if len(f.Idents) == 0 && len(f.HostIps) == 0 {
-		ginx.Bomb(http.StatusBadRequest, "idents or host_ips must be provided")
-	}
-
-	// Acquire idents by idents and hostIps
-	failedResults, f.Idents, err = models.TargetsGetIdentsByIdentsAndHostIps(rt.Ctx, f.Idents, f.HostIps)
-	if err != nil {
-		ginx.Bomb(http.StatusBadRequest, err.Error())
-	}
-
-	ginx.NewRender(c).Data(failedResults, models.TargetDel(rt.Ctx, f.Idents))
-}
-
-func (rt *Router) targetDelByService(c *gin.Context) {
-	var f identsForm
-	var err error
-	var failedResults = make(map[string]string)
-	ginx.BindJSON(c, &f)
-
-	if len(f.Idents) == 0 && len(f.HostIps) == 0 {
-		ginx.Bomb(http.StatusBadRequest, "idents or host_ips must be provided")
-	}
-
-	// Acquire idents by idents and hostIps
-	failedResults, f.Idents, err = models.TargetsGetIdentsByIdentsAndHostIps(rt.Ctx, f.Idents, f.HostIps)
-	if err != nil {
-		ginx.Bomb(http.StatusBadRequest, err.Error())
-	}
-
-	ginx.NewRender(c).Data(failedResults, models.TargetDel(rt.Ctx, f.Idents))
-}
-
-func (rt *Router) checkTargetPerm(c *gin.Context, idents []string) {
-	user := c.MustGet("user").(*models.User)
-	nopri, err := user.NopriIdents(rt.Ctx, idents)
-	ginx.Dangerous(err)
-
-	if len(nopri) > 0 {
-		ginx.Bomb(http.StatusForbidden, "No permission to operate the targets: %s", strings.Join(nopri, ", "))
-	}
-}
-
-func (rt *Router) targetsOfAlertRule(c *gin.Context) {
-	engineName := ginx.QueryStr(c, "engine_name", "")
-	m, err := models.GetTargetsOfHostAlertRule(rt.Ctx, engineName)
-	ret := make(map[string]map[int64][]string)
-	for en, v := range m {
-		if en != engineName {
-			continue
-		}
-
-		ret[en] = make(map[int64][]string)
-		for rid, idents := range v {
-			ret[en][rid] = idents
-		}
-	}
-
-	ginx.NewRender(c).Data(ret, err)
-}

center/router/router_task.go

@@ -1,154 +0,0 @@
-package router
-
-import (
-	"time"
-
-	"github.com/ccfos/nightingale/v6/alert/sender"
-	"github.com/ccfos/nightingale/v6/models"
-
-	"github.com/gin-gonic/gin"
-	"github.com/toolkits/pkg/ginx"
-	"github.com/toolkits/pkg/i18n"
-	"github.com/toolkits/pkg/str"
-)
-
-func (rt *Router) taskGets(c *gin.Context) {
-	bgid := ginx.UrlParamInt64(c, "id")
-	mine := ginx.QueryBool(c, "mine", false)
-	days := ginx.QueryInt64(c, "days", 7)
-	limit := ginx.QueryInt(c, "limit", 20)
-	query := ginx.QueryStr(c, "query", "")
-	user := c.MustGet("user").(*models.User)
-
-	creator := ""
-	if mine {
-		creator = user.Username
-	}
-
-	beginTime := time.Now().Unix() - days*24*3600
-
-	total, err := models.TaskRecordTotal(rt.Ctx, []int64{bgid}, beginTime, creator, query)
-	ginx.Dangerous(err)
-
-	list, err := models.TaskRecordGets(rt.Ctx, []int64{bgid}, beginTime, creator, query, limit, ginx.Offset(c, limit))
-	ginx.Dangerous(err)
-
-	ginx.NewRender(c).Data(gin.H{
-		"total": total,
-		"list":  list,
-	}, nil)
-}
-
-func (rt *Router) taskGetsByGids(c *gin.Context) {
-	gids := str.IdsInt64(ginx.QueryStr(c, "gids", ""), ",")
-	if len(gids) > 0 {
-		for _, gid := range gids {
-			rt.bgroCheck(c, gid)
-		}
-	} else {
-		me := c.MustGet("user").(*models.User)
-		if !me.IsAdmin() {
-			var err error
-			gids, err = models.MyBusiGroupIds(rt.Ctx, me.Id)
-			ginx.Dangerous(err)
-
-			if len(gids) == 0 {
-				ginx.NewRender(c).Data([]int{}, nil)
-				return
-			}
-		}
-	}
-
-	mine := ginx.QueryBool(c, "mine", false)
-	days := ginx.QueryInt64(c, "days", 7)
-	limit := ginx.QueryInt(c, "limit", 20)
-	query := ginx.QueryStr(c, "query", "")
-	user := c.MustGet("user").(*models.User)
-
-	creator := ""
-	if mine {
-		creator = user.Username
-	}
-
-	beginTime := time.Now().Unix() - days*24*3600
-
-	total, err := models.TaskRecordTotal(rt.Ctx, gids, beginTime, creator, query)
-	ginx.Dangerous(err)
-
-	list, err := models.TaskRecordGets(rt.Ctx, gids, beginTime, creator, query, limit, ginx.Offset(c, limit))
-	ginx.Dangerous(err)
-
-	ginx.NewRender(c).Data(gin.H{
-		"total": total,
-		"list":  list,
-	}, nil)
-}
-
-type taskForm struct {
-	Title     string   `json:"title" binding:"required"`
-	Account   string   `json:"account" binding:"required"`
-	Batch     int      `json:"batch"`
-	Tolerance int      `json:"tolerance"`
-	Timeout   int      `json:"timeout"`
-	Pause     string   `json:"pause"`
-	Script    string   `json:"script" binding:"required"`
-	Args      string   `json:"args"`
-	Action    string   `json:"action" binding:"required"`
-	Creator   string   `json:"creator"`
-	Hosts     []string `json:"hosts" binding:"required"`
-}
-
-func (rt *Router) taskRecordAdd(c *gin.Context) {
-	var f *models.TaskRecord
-	ginx.BindJSON(c, &f)
-	ginx.NewRender(c).Message(f.Add(rt.Ctx))
-}
-
-func (rt *Router) taskAdd(c *gin.Context) {
-	if !rt.Ibex.Enable {
-		ginx.Bomb(400, i18n.Sprintf(c.GetHeader("X-Language"), "This functionality has not been enabled. Please contact the system administrator to activate it."))
-		return
-	}
-
-	var f models.TaskForm
-	ginx.BindJSON(c, &f)
-
-	bgid := ginx.UrlParamInt64(c, "id")
-	user := c.MustGet("user").(*models.User)
-	f.Creator = user.Username
-
-	err := f.Verify()
-	ginx.Dangerous(err)
-
-	f.HandleFH(f.Hosts[0])
-
-	// check permission
-	rt.checkTargetPerm(c, f.Hosts)
-
-	// call ibex
-	taskId, err := sender.TaskAdd(f, user.Username, rt.Ctx.IsCenter)
-	ginx.Dangerous(err)
-
-	if taskId <= 0 {
-		ginx.Dangerous("created task.id is zero")
-	}
-
-	// write db
-	record := models.TaskRecord{
-		Id:        taskId,
-		GroupId:   bgid,
-		Title:     f.Title,
-		Account:   f.Account,
-		Batch:     f.Batch,
-		Tolerance: f.Tolerance,
-		Timeout:   f.Timeout,
-		Pause:     f.Pause,
-		Script:    f.Script,
-		Args:      f.Args,
-		CreateAt:  time.Now().Unix(),
-		CreateBy:  f.Creator,
-	}
-
-	err = record.Add(rt.Ctx)
-	ginx.NewRender(c).Data(taskId, err)
-}

center/router/router_tdengine.go

@@ -1,117 +0,0 @@
-package router
-
-import (
-	"net/http"
-
-	"github.com/ccfos/nightingale/v6/center/cconf"
-	"github.com/ccfos/nightingale/v6/models"
-
-	"github.com/gin-gonic/gin"
-	"github.com/toolkits/pkg/ginx"
-	"github.com/toolkits/pkg/logger"
-)
-
-type databasesQueryForm struct {
-	Cate         string `json:"cate" form:"cate"`
-	DatasourceId int64  `json:"datasource_id" form:"datasource_id"`
-}
-
-func (rt *Router) tdengineDatabases(c *gin.Context) {
-	var f databasesQueryForm
-	ginx.BindJSON(c, &f)
-
-	tdClient := rt.TdendgineClients.GetCli(f.DatasourceId)
-	if tdClient == nil {
-		ginx.NewRender(c, http.StatusNotFound).Message("No such datasource")
-		return
-	}
-
-	databases, err := tdClient.GetDatabases()
-	ginx.NewRender(c).Data(databases, err)
-}
-
-type tablesQueryForm struct {
-	Cate         string `json:"cate"`
-	DatasourceId int64  `json:"datasource_id" `
-	Database     string `json:"db"`
-	IsStable     bool   `json:"is_stable"`
-}
-
-// get tdengine tables
-func (rt *Router) tdengineTables(c *gin.Context) {
-	var f tablesQueryForm
-	ginx.BindJSON(c, &f)
-
-	tdClient := rt.TdendgineClients.GetCli(f.DatasourceId)
-	if tdClient == nil {
-		ginx.NewRender(c, http.StatusNotFound).Message("No such datasource")
-		return
-	}
-
-	tables, err := tdClient.GetTables(f.Database, f.IsStable)
-	ginx.NewRender(c).Data(tables, err)
-}
-
-type columnsQueryForm struct {
-	Cate         string `json:"cate"`
-	DatasourceId int64  `json:"datasource_id" `
-	Database     string `json:"db"`
-	Table        string `json:"table"`
-}
-
-// get tdengine columns
-func (rt *Router) tdengineColumns(c *gin.Context) {
-	var f columnsQueryForm
-	ginx.BindJSON(c, &f)
-
-	tdClient := rt.TdendgineClients.GetCli(f.DatasourceId)
-	if tdClient == nil {
-		ginx.NewRender(c, http.StatusNotFound).Message("No such datasource")
-		return
-	}
-
-	columns, err := tdClient.GetColumns(f.Database, f.Table)
-	ginx.NewRender(c).Data(columns, err)
-}
-
-func (rt *Router) QueryData(c *gin.Context) {
-	var f models.QueryParam
-	ginx.BindJSON(c, &f)
-
-	var resp []models.DataResp
-	var err error
-	tdClient := rt.TdendgineClients.GetCli(f.DatasourceId)
-	for _, q := range f.Querys {
-		datas, err := tdClient.Query(q)
-		ginx.Dangerous(err)
-		resp = append(resp, datas...)
-	}
-
-	ginx.NewRender(c).Data(resp, err)
-}
-
-func (rt *Router) QueryLog(c *gin.Context) {
-	var f models.QueryParam
-	ginx.BindJSON(c, &f)
-
-	tdClient := rt.TdendgineClients.GetCli(f.DatasourceId)
-	if len(f.Querys) == 0 {
-		ginx.Bomb(200, "querys is empty")
-		return
-	}
-
-	data, err := tdClient.QueryLog(f.Querys[0])
-	logger.Debugf("tdengine query:%s result: %+v", f.Querys[0], data)
-	ginx.NewRender(c).Data(data, err)
-}
-
-// query sql template
-func (rt *Router) QuerySqlTemplate(c *gin.Context) {
-	cate := ginx.QueryStr(c, "cate")
-	m := make(map[string]string)
-	switch cate {
-	case models.TDENGINE:
-		m = cconf.TDengineSQLTpl
-	}
-	ginx.NewRender(c).Data(m, nil)
-}

center/router/router_user.go

@@ -1,222 +0,0 @@
-package router
-
-import (
-	"net/http"
-	"strings"
-
-	"github.com/ccfos/nightingale/v6/models"
-	"github.com/ccfos/nightingale/v6/pkg/flashduty"
-	"github.com/ccfos/nightingale/v6/pkg/ormx"
-	"github.com/ccfos/nightingale/v6/pkg/secu"
-
-	"github.com/gin-gonic/gin"
-	"github.com/toolkits/pkg/ginx"
-	"github.com/toolkits/pkg/logger"
-)
-
-func (rt *Router) userBusiGroupsGets(c *gin.Context) {
-	userid := ginx.QueryInt64(c, "userid", 0)
-	username := ginx.QueryStr(c, "username", "")
-
-	if userid == 0 && username == "" {
-		ginx.Bomb(http.StatusBadRequest, "userid or username required")
-	}
-
-	var user *models.User
-	var err error
-	if userid > 0 {
-		user, err = models.UserGetById(rt.Ctx, userid)
-	} else {
-		user, err = models.UserGetByUsername(rt.Ctx, username)
-	}
-
-	ginx.Dangerous(err)
-
-	groups, err := user.BusiGroups(rt.Ctx, 10000, "")
-	ginx.NewRender(c).Data(groups, err)
-}
-
-func (rt *Router) userFindAll(c *gin.Context) {
-	list, err := models.UserGetAll(rt.Ctx)
-	ginx.NewRender(c).Data(list, err)
-}
-
-func (rt *Router) userGets(c *gin.Context) {
-	stime, etime := getTimeRange(c)
-	limit := ginx.QueryInt(c, "limit", 20)
-	query := ginx.QueryStr(c, "query", "")
-	order := ginx.QueryStr(c, "order", "username")
-	desc := ginx.QueryBool(c, "desc", false)
-
-	rt.UserCache.UpdateUsersLastActiveTime()
-	total, err := models.UserTotal(rt.Ctx, query, stime, etime)
-	ginx.Dangerous(err)
-
-	list, err := models.UserGets(rt.Ctx, query, limit, ginx.Offset(c, limit), stime, etime, order, desc)
-	ginx.Dangerous(err)
-
-	user := c.MustGet("user").(*models.User)
-
-	ginx.NewRender(c).Data(gin.H{
-		"list":  list,
-		"total": total,
-		"admin": user.IsAdmin(),
-	}, nil)
-}
-
-type userAddForm struct {
-	Username string       `json:"username" binding:"required"`
-	Password string       `json:"password" binding:"required"`
-	Nickname string       `json:"nickname"`
-	Phone    string       `json:"phone"`
-	Email    string       `json:"email"`
-	Portrait string       `json:"portrait"`
-	Roles    []string     `json:"roles" binding:"required"`
-	Contacts ormx.JSONObj `json:"contacts"`
-}
-
-func (rt *Router) userAddPost(c *gin.Context) {
-	var f userAddForm
-	ginx.BindJSON(c, &f)
-
-	authPassWord := f.Password
-	if rt.HTTP.RSA.OpenRSA {
-		decPassWord, err := secu.Decrypt(f.Password, rt.HTTP.RSA.RSAPrivateKey, rt.HTTP.RSA.RSAPassWord)
-		if err != nil {
-			logger.Errorf("RSA Decrypt failed: %v username: %s", err, f.Username)
-			ginx.NewRender(c).Message(err)
-			return
-		}
-		authPassWord = decPassWord
-	}
-
-	password, err := models.CryptoPass(rt.Ctx, authPassWord)
-	ginx.Dangerous(err)
-
-	if len(f.Roles) == 0 {
-		ginx.Bomb(http.StatusBadRequest, "roles empty")
-	}
-
-	username := Username(c)
-
-	u := models.User{
-		Username: f.Username,
-		Password: password,
-		Nickname: f.Nickname,
-		Phone:    f.Phone,
-		Email:    f.Email,
-		Portrait: f.Portrait,
-		Roles:    strings.Join(f.Roles, " "),
-		Contacts: f.Contacts,
-		CreateBy: username,
-		UpdateBy: username,
-	}
-
-	ginx.Dangerous(u.Verify())
-	ginx.NewRender(c).Message(u.Add(rt.Ctx))
-}
-
-func (rt *Router) userProfileGet(c *gin.Context) {
-	user := User(rt.Ctx, ginx.UrlParamInt64(c, "id"))
-	ginx.NewRender(c).Data(user, nil)
-}
-
-type userProfileForm struct {
-	Nickname string       `json:"nickname"`
-	Phone    string       `json:"phone"`
-	Email    string       `json:"email"`
-	Roles    []string     `json:"roles"`
-	Contacts ormx.JSONObj `json:"contacts"`
-}
-
-func (rt *Router) userProfilePutByService(c *gin.Context) {
-	var f models.User
-	ginx.BindJSON(c, &f)
-
-	if len(f.RolesLst) == 0 {
-		ginx.Bomb(http.StatusBadRequest, "roles empty")
-	}
-
-	password, err := models.CryptoPass(rt.Ctx, f.Password)
-	ginx.Dangerous(err)
-
-	target := User(rt.Ctx, ginx.UrlParamInt64(c, "id"))
-	target.Nickname = f.Nickname
-	target.Password = password
-	target.Phone = f.Phone
-	target.Email = f.Email
-	target.Portrait = f.Portrait
-	target.Roles = strings.Join(f.RolesLst, " ")
-	target.Contacts = f.Contacts
-	target.UpdateBy = Username(c)
-
-	ginx.NewRender(c).Message(target.UpdateAllFields(rt.Ctx))
-}
-
-func (rt *Router) userProfilePut(c *gin.Context) {
-	var f userProfileForm
-	ginx.BindJSON(c, &f)
-
-	if len(f.Roles) == 0 {
-		ginx.Bomb(http.StatusBadRequest, "roles empty")
-	}
-
-	target := User(rt.Ctx, ginx.UrlParamInt64(c, "id"))
-	oldInfo := models.User{
-		Username: target.Username,
-		Phone:    target.Phone,
-		Email:    target.Email,
-	}
-	target.Nickname = f.Nickname
-	target.Phone = f.Phone
-	target.Email = f.Email
-	target.Roles = strings.Join(f.Roles, " ")
-	target.Contacts = f.Contacts
-	target.UpdateBy = c.MustGet("username").(string)
-
-	if flashduty.NeedSyncUser(rt.Ctx) {
-		flashduty.UpdateUser(rt.Ctx, oldInfo, f.Email, f.Phone)
-	}
-
-	ginx.NewRender(c).Message(target.UpdateAllFields(rt.Ctx))
-}
-
-type userPasswordForm struct {
-	Password string `json:"password" binding:"required"`
-}
-
-func (rt *Router) userPasswordPut(c *gin.Context) {
-	var f userPasswordForm
-	ginx.BindJSON(c, &f)
-
-	target := User(rt.Ctx, ginx.UrlParamInt64(c, "id"))
-
-	authPassWord := f.Password
-	if rt.HTTP.RSA.OpenRSA {
-		decPassWord, err := secu.Decrypt(f.Password, rt.HTTP.RSA.RSAPrivateKey, rt.HTTP.RSA.RSAPassWord)
-		if err != nil {
-			logger.Errorf("RSA Decrypt failed: %v username: %s", err, target.Username)
-			ginx.NewRender(c).Message(err)
-			return
-		}
-		authPassWord = decPassWord
-	}
-
-	cryptoPass, err := models.CryptoPass(rt.Ctx, authPassWord)
-	ginx.Dangerous(err)
-
-	ginx.NewRender(c).Message(target.UpdatePassword(rt.Ctx, cryptoPass, c.MustGet("username").(string)))
-}
-
-func (rt *Router) userDel(c *gin.Context) {
-	id := ginx.UrlParamInt64(c, "id")
-	target, err := models.UserGetById(rt.Ctx, id)
-	ginx.Dangerous(err)
-
-	if target == nil {
-		ginx.NewRender(c).Message(nil)
-		return
-	}
-
-	ginx.NewRender(c).Message(target.Del(rt.Ctx))
-}

center/router/router_user_group.go

@@ -1,217 +0,0 @@
-package router
-
-import (
-	"net/http"
-	"time"
-
-	"github.com/ccfos/nightingale/v6/models"
-	"github.com/ccfos/nightingale/v6/pkg/flashduty"
-
-	"github.com/gin-gonic/gin"
-	"github.com/toolkits/pkg/ginx"
-	"github.com/toolkits/pkg/logger"
-	"github.com/toolkits/pkg/str"
-)
-
-func (rt *Router) checkBusiGroupPerm(c *gin.Context) {
-	me := c.MustGet("user").(*models.User)
-	bg := BusiGroup(rt.Ctx, ginx.UrlParamInt64(c, "id"))
-
-	can, err := me.CanDoBusiGroup(rt.Ctx, bg, ginx.UrlParamStr(c, "perm"))
-	ginx.NewRender(c).Data(can, err)
-}
-
-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(rt.Ctx, limit, query)
-
-	ginx.NewRender(c).Data(lst, err)
-}
-
-func (rt *Router) userGroupGetsByService(c *gin.Context) {
-	ids := str.IdsInt64(ginx.QueryStr(c, "ids", ""))
-
-	if len(ids) == 0 {
-		lst, err := models.UserGroupGetAll(rt.Ctx)
-		ginx.Dangerous(err)
-		for i := 0; i < len(lst); i++ {
-			ids, err := models.MemberIds(rt.Ctx, lst[i].Id)
-			ginx.Dangerous(err)
-
-			lst[i].Users, err = models.UserGetsByIds(rt.Ctx, ids)
-			ginx.Dangerous(err)
-		}
-		ginx.NewRender(c).Data(lst, err)
-		return
-	}
-
-	lst := make([]models.UserGroup, 0)
-	for _, id := range ids {
-		ug := UserGroup(rt.Ctx, id)
-
-		ids, err := models.MemberIds(rt.Ctx, ug.Id)
-		ginx.Dangerous(err)
-
-		ug.Users, err = models.UserGetsByIds(rt.Ctx, ids)
-		ginx.Dangerous(err)
-
-		lst = append(lst, *ug)
-	}
-
-	ginx.NewRender(c).Data(lst, nil)
-}
-
-// user group member get by service
-func (rt *Router) userGroupMemberGetsByService(c *gin.Context) {
-	members, err := models.UserGroupMemberGetAll(rt.Ctx)
-	ginx.NewRender(c).Data(members, err)
-}
-
-type userGroupForm struct {
-	Name              string `json:"name" binding:"required"`
-	Note              string `json:"note"`
-	IsSyncToFlashDuty bool   `json:"is_sync_to_flashduty"`
-}
-
-func (rt *Router) userGroupAdd(c *gin.Context) {
-	var f userGroupForm
-	ginx.BindJSON(c, &f)
-
-	me := c.MustGet("user").(*models.User)
-
-	ug := models.UserGroup{
-		Name:     f.Name,
-		Note:     f.Note,
-		CreateBy: me.Username,
-		UpdateBy: me.Username,
-	}
-
-	err := ug.Add(rt.Ctx)
-	ginx.Dangerous(err)
-
-	// Even failure is not a big deal
-	models.UserGroupMemberAdd(rt.Ctx, ug.Id, me.Id)
-
-	if f.IsSyncToFlashDuty || flashduty.NeedSyncTeam(rt.Ctx) {
-		ugs, err := flashduty.NewUserGroupSyncer(rt.Ctx, &ug)
-		ginx.Dangerous(err)
-		err = ugs.SyncUGAdd()
-		ginx.Dangerous(err)
-	}
-	ginx.NewRender(c).Data(ug.Id, err)
-
-}
-
-func (rt *Router) userGroupPut(c *gin.Context) {
-	var f userGroupForm
-	ginx.BindJSON(c, &f)
-
-	me := c.MustGet("user").(*models.User)
-	ug := c.MustGet("user_group").(*models.UserGroup)
-	oldUGName := ug.Name
-
-	if ug.Name != f.Name {
-		// name changed, check duplication
-		num, err := models.UserGroupCount(rt.Ctx, "name=? and id<>?", f.Name, ug.Id)
-		ginx.Dangerous(err)
-
-		if num > 0 {
-			ginx.Bomb(http.StatusOK, "UserGroup already exists")
-		}
-	}
-
-	ug.Name = f.Name
-	ug.Note = f.Note
-	ug.UpdateBy = me.Username
-	ug.UpdateAt = time.Now().Unix()
-	if f.IsSyncToFlashDuty || flashduty.NeedSyncTeam(rt.Ctx) {
-		ugs, err := flashduty.NewUserGroupSyncer(rt.Ctx, ug)
-		ginx.Dangerous(err)
-		err = ugs.SyncUGPut(oldUGName)
-		ginx.Dangerous(err)
-	}
-	ginx.NewRender(c).Message(ug.Update(rt.Ctx, "Name", "Note", "UpdateAt", "UpdateBy"))
-
-}
-
-// Return all members, front-end search and paging
-func (rt *Router) userGroupGet(c *gin.Context) {
-	ug := UserGroup(rt.Ctx, ginx.UrlParamInt64(c, "id"))
-
-	ids, err := models.MemberIds(rt.Ctx, ug.Id)
-	ginx.Dangerous(err)
-
-	logger.Info("userGroupGet", ids)
-	users, err := models.UserGetsByIds(rt.Ctx, ids)
-
-	ginx.NewRender(c).Data(gin.H{
-		"users":      users,
-		"user_group": ug,
-	}, err)
-}
-
-func (rt *Router) userGroupDel(c *gin.Context) {
-	isSyncToFlashDuty := ginx.QueryBool(c, "is_sync_to_flashduty", false)
-	ug := c.MustGet("user_group").(*models.UserGroup)
-	if isSyncToFlashDuty || flashduty.NeedSyncTeam(rt.Ctx) {
-		ugs, err := flashduty.NewUserGroupSyncer(rt.Ctx, ug)
-		ginx.Dangerous(err)
-		err = ugs.SyncUGDel(ug.Name)
-		ginx.Dangerous(err)
-	}
-	ginx.NewRender(c).Message(ug.Del(rt.Ctx))
-
-}
-
-func (rt *Router) userGroupMemberAdd(c *gin.Context) {
-	var f idsForm
-	ginx.BindJSON(c, &f)
-	f.Verify()
-
-	me := c.MustGet("user").(*models.User)
-	ug := c.MustGet("user_group").(*models.UserGroup)
-
-	err := ug.AddMembers(rt.Ctx, f.Ids)
-	ginx.Dangerous(err)
-	if err == nil {
-		ug.UpdateAt = time.Now().Unix()
-		ug.UpdateBy = me.Username
-		ug.Update(rt.Ctx, "UpdateAt", "UpdateBy")
-	}
-
-	if f.IsSyncToFlashDuty || flashduty.NeedSyncTeam(rt.Ctx) {
-		ugs, err := flashduty.NewUserGroupSyncer(rt.Ctx, ug)
-		ginx.Dangerous(err)
-		err = ugs.SyncMembersAdd()
-		ginx.Dangerous(err)
-	}
-	ginx.NewRender(c).Message(err)
-
-}
-
-func (rt *Router) userGroupMemberDel(c *gin.Context) {
-	var f idsForm
-	ginx.BindJSON(c, &f)
-	f.Verify()
-
-	me := c.MustGet("user").(*models.User)
-	ug := c.MustGet("user_group").(*models.UserGroup)
-
-	err := ug.DelMembers(rt.Ctx, f.Ids)
-	if err == nil {
-		ug.UpdateAt = time.Now().Unix()
-		ug.UpdateBy = me.Username
-		ug.Update(rt.Ctx, "UpdateAt", "UpdateBy")
-	}
-	if f.IsSyncToFlashDuty || flashduty.NeedSyncTeam(rt.Ctx) {
-		ugs, err := flashduty.NewUserGroupSyncer(rt.Ctx, ug)
-		ginx.Dangerous(err)
-		err = ugs.SyncMembersDel()
-		ginx.Dangerous(err)
-	}
-
-	ginx.NewRender(c).Message(err)
-}

center/router/router_user_variable_config.go

@@ -1,70 +0,0 @@
-package router
-
-import (
-	"strings"
-	"time"
-
-	"github.com/ccfos/nightingale/v6/models"
-
-	"github.com/gin-gonic/gin"
-	"github.com/toolkits/pkg/ginx"
-)
-
-func (rt *Router) userVariableConfigGets(context *gin.Context) {
-	userVariables, err := models.ConfigsGetUserVariable(rt.Ctx)
-	ginx.NewRender(context).Data(userVariables, err)
-}
-func (rt *Router) userVariableConfigAdd(context *gin.Context) {
-	var f models.Configs
-	ginx.BindJSON(context, &f)
-	f.Ckey = strings.TrimSpace(f.Ckey)
-	//insert external config. needs to make sure not plaintext for an encrypted type config
-	username := context.MustGet("username").(string)
-	now := time.Now().Unix()
-	f.CreateBy = username
-	f.UpdateBy = username
-	f.CreateAt = now
-	f.UpdateAt = now
-	ginx.NewRender(context).Message(models.ConfigsUserVariableInsert(rt.Ctx, f))
-
-}
-
-func (rt *Router) userVariableConfigPut(context *gin.Context) {
-	var f models.Configs
-	ginx.BindJSON(context, &f)
-	f.Id = ginx.UrlParamInt64(context, "id")
-	f.Ckey = strings.TrimSpace(f.Ckey)
-	f.UpdateBy = context.MustGet("username").(string)
-	f.UpdateAt = time.Now().Unix()
-
-	user := context.MustGet("user").(*models.User)
-	if !user.IsAdmin() && f.CreateBy != user.Username {
-		// only admin or creator can update
-		ginx.Bomb(403, "no permission")
-	}
-
-	ginx.NewRender(context).Message(models.ConfigsUserVariableUpdate(rt.Ctx, f))
-}
-
-func (rt *Router) userVariableConfigDel(context *gin.Context) {
-	id := ginx.UrlParamInt64(context, "id")
-	configs, err := models.ConfigGet(rt.Ctx, id)
-	ginx.Dangerous(err)
-
-	user := context.MustGet("user").(*models.User)
-	if !user.IsAdmin() && configs.CreateBy != user.Username {
-		// only admin or creator can delete
-		ginx.Bomb(403, "no permission")
-	}
-
-	if configs != nil && configs.External == models.ConfigExternal {
-		ginx.NewRender(context).Message(models.ConfigsDel(rt.Ctx, []int64{id}))
-	} else {
-		ginx.NewRender(context).Message(nil)
-	}
-}
-
-func (rt *Router) userVariableGetDecryptByService(context *gin.Context) {
-	decryptMap, decryptErr := models.ConfigUserVariableGetDecryptMap(rt.Ctx, rt.HTTP.RSA.RSAPrivateKey, rt.HTTP.RSA.RSAPassWord)
-	ginx.NewRender(context).Data(decryptMap, decryptErr)
-}

center/sso/init.go

@@ -1,277 +0,0 @@
-package sso
-
-import (
-	"log"
-	"time"
-
-	"github.com/ccfos/nightingale/v6/center/cconf"
-	"github.com/ccfos/nightingale/v6/memsto"
-	"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/ccfos/nightingale/v6/pkg/tplx"
-
-	"github.com/BurntSushi/toml"
-	"github.com/toolkits/pkg/logger"
-)
-
-type SsoClient struct {
-	OIDC                 *oidcx.SsoClient
-	LDAP                 *ldapx.SsoClient
-	CAS                  *cas.SsoClient
-	OAuth2               *oauth2x.SsoClient
-	LastUpdateTime       int64
-	configCache          *memsto.ConfigCache
-	configLastUpdateTime int64
-}
-
-const LDAP = `
-Enable = false
-Host = 'ldap.example.org'
-Port = 389
-BaseDn = 'dc=example,dc=org'
-BindUser = 'cn=manager,dc=example,dc=org'
-BindPass = '*******'
-SyncAddUsers = false
-SyncDelUsers = false
-# unit: s
-SyncInterval = 86400
-# openldap format e.g. (&(uid=%s))
-# AD format e.g. (&(sAMAccountName=%s))
-AuthFilter = '(&(uid=%s))'
-UserFilter = '(&(uid=*))'
-CoverAttributes = true
-TLS = false
-StartTLS = true
-DefaultRoles = ['Standard']
-
-[Attributes]
-Username = 'uid'
-Nickname = 'cn'
-Phone = 'mobile'
-Email = 'mail'
-`
-
-const OAuth2 = `
-Enable = false
-DisplayName = 'OAuth2登录'
-RedirectURL = 'http://n9e.com/callback/oauth'
-SsoAddr = 'https://sso.example.com/oauth2/authorize'
-SsoLogoutAddr = 'https://sso.example.com/oauth2/authorize/session/end'
-TokenAddr = 'https://sso.example.com/oauth2/token'
-UserInfoAddr = 'https://api.example.com/api/v1/user/info'
-TranTokenMethod = 'header'
-ClientId = ''
-ClientSecret = ''
-CoverAttributes = true
-DefaultRoles = ['Standard']
-UserinfoIsArray = false
-UserinfoPrefix = 'data'
-Scopes = ['profile', 'email', 'phone']
-
-[Attributes]
-Username = 'sub'
-Nickname = 'nickname'
-Phone = 'phone_number'
-Email = 'email'
-`
-
-const CAS = `
-Enable = false
-DisplayName = 'CAS登录'
-RedirectURL = 'http://n9e.com/callback/cas'
-SsoAddr = 'https://cas.example.com/cas/'
-SsoLogoutAddr = 'https://cas.example.com/cas/session/end'
-# LoginPath = ''
-CoverAttributes = true
-DefaultRoles = ['Standard']
-
-[Attributes]
-Username = 'sub'
-Nickname = 'nickname'
-Phone = 'phone_number'
-Email = 'email'
-`
-
-const OIDC = `
-Enable = false
-DisplayName = 'OIDC登录'
-RedirectURL = 'http://n9e.com/callback'
-SsoAddr = 'http://sso.example.org'
-SsoLogoutAddr = 'http://sso.example.org/session/end'
-ClientId = ''
-ClientSecret = ''
-CoverAttributes = true
-DefaultRoles = ['Standard']
-Scopes = ['openid', 'profile', 'email', 'phone']
-
-[Attributes]
-Username = 'sub'
-Nickname = 'nickname'
-Phone = 'phone_number'
-Email = 'email'
-`
-
-func Init(center cconf.Center, ctx *ctx.Context, configCache *memsto.ConfigCache) *SsoClient {
-	ssoClient := new(SsoClient)
-	m := make(map[string]string)
-	m["LDAP"] = LDAP
-	m["CAS"] = CAS
-	m["OIDC"] = OIDC
-	m["OAuth2"] = OAuth2
-
-	for name, config := range m {
-		count, err := models.SsoConfigCountByName(ctx, name)
-		if err != nil {
-			logger.Error(err)
-			continue
-		}
-
-		if count > 0 {
-			continue
-		}
-
-		ssoConfig := models.SsoConfig{
-			Name:    name,
-			Content: config,
-		}
-
-		err = ssoConfig.Create(ctx)
-		if err != nil {
-			log.Fatalln(err)
-		}
-	}
-	if configCache == nil {
-		logger.Error("configCache is nil, sso initialization failed")
-	}
-	ssoClient.configCache = configCache
-	userVariableMap := configCache.Get()
-
-	configs, err := models.SsoConfigGets(ctx)
-	if err != nil {
-		log.Fatalln(err)
-	}
-
-	for _, cfg := range configs {
-		cfg.Content = tplx.ReplaceTemplateUseText(cfg.Name, cfg.Content, userVariableMap)
-		switch cfg.Name {
-		case "LDAP":
-			var config ldapx.Config
-			err := toml.Unmarshal([]byte(cfg.Content), &config)
-			if err != nil {
-				log.Fatalln("init ldap failed", err)
-			}
-			ssoClient.LDAP = ldapx.New(config)
-		case "OIDC":
-			var config oidcx.Config
-			err := toml.Unmarshal([]byte(cfg.Content), &config)
-			if err != nil {
-				log.Fatalln("init oidc failed:", err)
-			}
-			logger.Info("init oidc..")
-			oidcClient, err := oidcx.New(config)
-			if err != nil {
-				logger.Error("init oidc failed:", err)
-			} else {
-				ssoClient.OIDC = oidcClient
-			}
-		case "CAS":
-			var config cas.Config
-			err := toml.Unmarshal([]byte(cfg.Content), &config)
-			if err != nil {
-				log.Fatalln("init cas failed:", err)
-			}
-			ssoClient.CAS = cas.New(config)
-		case "OAuth2":
-			var config oauth2x.Config
-			err := toml.Unmarshal([]byte(cfg.Content), &config)
-			if err != nil {
-				log.Fatalln("init oauth2 failed:", err)
-			}
-			ssoClient.OAuth2 = oauth2x.New(config)
-		}
-	}
-
-	go ssoClient.SyncSsoUsers(ctx)
-	go ssoClient.Reload(ctx)
-	return ssoClient
-}
-
-// 定期更新sso配置
-func (s *SsoClient) reload(ctx *ctx.Context) error {
-	lastUpdateTime, err := models.SsoConfigLastUpdateTime(ctx)
-	if err != nil {
-		return err
-	}
-
-	lastCacheUpdateTime := s.configCache.GetLastUpdateTime()
-	if lastUpdateTime == s.LastUpdateTime && lastCacheUpdateTime == s.configLastUpdateTime {
-		return nil
-	}
-
-	configs, err := models.SsoConfigGets(ctx)
-	if err != nil {
-		return err
-	}
-	userVariableMap := s.configCache.Get()
-	for _, cfg := range configs {
-		cfg.Content = tplx.ReplaceTemplateUseText(cfg.Name, cfg.Content, userVariableMap)
-		switch cfg.Name {
-		case "LDAP":
-			var config ldapx.Config
-			err := toml.Unmarshal([]byte(cfg.Content), &config)
-			if err != nil {
-				logger.Warning("reload ldap failed", err)
-				continue
-			}
-			s.LDAP.Reload(config)
-		case "OIDC":
-			var config oidcx.Config
-			err := toml.Unmarshal([]byte(cfg.Content), &config)
-			if err != nil {
-				logger.Warning("reload oidc failed:", err)
-				continue
-			}
-
-			logger.Info("reload oidc..")
-			err = s.OIDC.Reload(config)
-			if err != nil {
-				logger.Error("reload oidc failed:", err)
-				continue
-			}
-		case "CAS":
-			var config cas.Config
-			err := toml.Unmarshal([]byte(cfg.Content), &config)
-			if err != nil {
-				logger.Warning("reload cas failed:", err)
-				continue
-			}
-			s.CAS.Reload(config)
-		case "OAuth2":
-			var config oauth2x.Config
-			err := toml.Unmarshal([]byte(cfg.Content), &config)
-			if err != nil {
-				logger.Warning("reload oauth2 failed:", err)
-				continue
-			}
-			s.OAuth2.Reload(config)
-		}
-	}
-
-	s.LastUpdateTime = lastUpdateTime
-	s.configLastUpdateTime = lastCacheUpdateTime
-	return nil
-}
-
-func (s *SsoClient) Reload(ctx *ctx.Context) {
-	duration := time.Duration(9000) * time.Millisecond
-	for {
-		time.Sleep(duration)
-		if err := s.reload(ctx); err != nil {
-			logger.Warning("reload sso client err:", err)
-		}
-	}
-}

center/sso/sync.go

@@ -1,37 +0,0 @@
-package sso
-
-import (
-	"fmt"
-
-	"github.com/ccfos/nightingale/v6/pkg/ctx"
-	"github.com/toolkits/pkg/logger"
-)
-
-func (s *SsoClient) SyncSsoUsers(ctx *ctx.Context) {
-	if err := s.LDAP.SyncAddAndDelUsers(ctx); err != nil {
-		fmt.Println("failed to sync the addition and deletion of ldap users:", err)
-	}
-
-	if err := s.LDAP.SyncDelUsers(ctx); err != nil {
-		fmt.Println("failed to sync deletion of ldap users:", err)
-	}
-
-	go s.loopSyncSsoUsers(ctx)
-}
-
-func (s *SsoClient) loopSyncSsoUsers(ctx *ctx.Context) {
-	for {
-		select {
-		case <-s.LDAP.Ticker.C:
-			lc := s.LDAP.Copy()
-
-			if err := lc.SyncAddAndDelUsers(ctx); err != nil {
-				logger.Warningf("failed to sync the addition and deletion of ldap users: %v", err)
-			}
-
-			if err := lc.SyncDelUsers(ctx); err != nil {
-				logger.Warningf("failed to sync deletion of ldap users: %v", err)
-			}
-		}
-	}
-}

cli/cli.go

@@ -1,9 +0,0 @@
-package cli
-
-import (
-	"github.com/ccfos/nightingale/v6/cli/upgrade"
-)
-
-func Upgrade(configFile string) error {
-	return upgrade.Upgrade(configFile)
-}

cli/upgrade/config.go

@@ -1,63 +0,0 @@
-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)
-}

cli/upgrade/readme.md

@@ -1,21 +0,0 @@
-# v5 升级 v6 手册
-0. 操作之前，记得备注下数据库！
-
-1. 需要先将你正在使用的夜莺数据源表结构更新到和 v5.15.0 一致，[release](https://github.com/ccfos/nightingale/releases) 页面有每个版本表结构的更新说明，可以根据你正在使用的版本，按照说明，逐个执行的更新表结构的语句
-
-2. 解压 n9e 安装包，导入 upgrade.sql 到 n9e_v5 数据库
-```
-mysql -h 127.0.0.1 -u root -p1234 < cli/upgrade/upgrade.sql
-```
-
-3. 执行 n9e-cli 完成数据库表结构升级, webapi.conf 为 v5 版本 n9e-webapi 正在使用的配置文件
-```
-./n9e-cli --upgrade --config webapi.conf
-```
-
-4. 修改 n9e 配置文件中的数据库为 n9e_v5，启动 n9e 进程
-```
-nohup ./n9e &> n9e.log &
-```
-
-5. n9e 监听的端口为 17000，需要将之前的 web 端口和数据上报的端口，都调整为 17000