shumengya/mengyaping
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

chore: sync local updates

Browse Source
This commit is contained in:
树萌芽
2026-05-16 19:03:32 +08:00
parent 360a5f15b9
commit aff88ba97d
47 changed files with 3651 additions and 12175 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
mengyaping-backend/.gitignore vendored Normal file
View File

@@ -0,0 +1,3 @@
# 本地交叉编译产物（部署时再生成）
dist/mengyaping-backend
dist/mengyaping-backend.exe

45
mengyaping-backend/Dockerfile
View File

@@ -1,56 +1,31 @@
# 多阶段构建 - 使用官方 Golang 镜像作为构建环境
FROM golang:1.25-alpine AS builder
# 生产镜像：使用本机预编译的 Linux amd64 二进制（避免在服务器 docker build 时再跑 go build）
# Windows: 先双击运行 build-linux-amd64.bat，生成 dist/mengyaping-backend 后再执行:
# docker compose build
# 若需在容器内编译，请使用: docker build -f Dockerfile.source .
# 设置工作目录
WORKDIR /app
FROM alpine:3.21
# 安装必要的构建工具
RUN apk add --no-cache git ca-certificates tzdata
RUN apk --no-cache add ca-certificates tzdata wget
# 复制 go.mod 和 go.sum 文件
COPY go.mod go.sum ./
# 下载依赖
RUN go mod download
# 复制源代码
COPY . .
# 构建应用程序
RUN CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -a -installsuffix cgo -o mengyaping-backend .
# 使用轻量级的 alpine 镜像作为运行环境
FROM alpine:latest
# 安装必要的运行时依赖
RUN apk --no-cache add ca-certificates tzdata
# 设置时区为上海
RUN cp /usr/share/zoneinfo/Asia/Shanghai /etc/localtime && \
echo "Asia/Shanghai" > /etc/timezone
# 创建非 root 用户
RUN addgroup -g 1000 appuser && \
adduser -D -u 1000 -G appuser appuser
# 设置工作目录
WORKDIR /app
# 从构建阶段复制编译好的二进制文件
COPY --from=builder /app/mengyaping-backend .
COPY dist/mengyaping-backend /app/mengyaping-backend
# 创建数据目录
RUN mkdir -p /app/data && chown -R appuser:appuser /app
RUN chmod +x /app/mengyaping-backend && \
mkdir -p /app/data && \
chown -R appuser:appuser /app
# 切换到非 root 用户
USER appuser
# 暴露端口
EXPOSE 8080
# 健康检查
HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
CMD wget --no-verbose --tries=1 --spider http://localhost:8080/api/health || exit 1
# 运行应用程序
CMD ["./mengyaping-backend"]

35
mengyaping-backend/build-linux-amd64.bat Normal file
View File

@@ -0,0 +1,35 @@
@echo off
chcp 65001 >nul 2>&1
setlocal
cd /d "%~dp0"
where go >nul 2>nul
if errorlevel 1 (
echo [ERROR] Go not found in PATH. Install Go and reopen the terminal.
pause
exit /b 1
)
set "DIST=dist"
if not exist "%DIST%" mkdir "%DIST%"
set "GOOS=linux"
set "GOARCH=amd64"
set "CGO_ENABLED=0"
echo Cross-compile linux/amd64 -^> "%DIST%\mengyaping-backend"
go version
go build -trimpath -ldflags="-s -w" -o "%DIST%\mengyaping-backend" .
if errorlevel 1 (
echo.
echo [ERROR] go build failed. See messages above.
echo Tips: go.mod requires Go 1.25+; run from mengyaping-backend folder.
pause
exit /b 1
)
echo.
echo [OK] "%CD%\%DIST%\mengyaping-backend"
echo Next: copy this folder to server, then: docker compose build
endlocal
exit /b 0

136
mengyaping-backend/cmd/importjson/main.go Normal file
View File

@@ -0,0 +1,136 @@
// 将 data/*.json（站点与分组）导入 MySQL。建议空库首次使用，或加 -wipe 清空业务表后再导。
//
// go run ./cmd/importjson -data ./data -wipe
package main
import (
"encoding/json"
"flag"
"fmt"
"log"
"os"
"path/filepath"
"gorm.io/datatypes"
"gorm.io/driver/mysql"
"gorm.io/gorm"
"gorm.io/gorm/logger"
"mengyaping-backend/config"
"mengyaping-backend/models"
"mengyaping-backend/storage"
)
func main() {
dataDir := flag.String("data", "./data", "JSON 目录（websites.json、groups.json）")
wipe := flag.Bool("wipe", false, "导入前 TRUNCATE 所有 monitor_* 表（慎用）")
flag.Parse()
cfg := config.GetConfig()
// 大批量 INSERT 时单条超过 200ms 会触发 GORM 默认「SLOW SQL」提示，易被误认为报错；导入工具改为静默 SQL 日志
db, err := gorm.Open(mysql.Open(cfg.DatabaseDSN()), &gorm.Config{
Logger: logger.Default.LogMode(logger.Silent),
})
if err != nil {
log.Fatal(err)
}
if err := db.AutoMigrate(
&storage.MonitorGroup{},
&storage.MonitorWebsite{},
&storage.MonitorWebsiteURL{},
&storage.MonitorWebsiteGroup{},
&storage.MonitorProbeLatest{},
&storage.MonitorProbeHour{},
&storage.MonitorProbeDay{},
&storage.MonitorKV{},
); err != nil {
log.Fatal(err)
}
if *wipe {
_ = db.Exec("SET FOREIGN_KEY_CHECKS = 0").Error
for _, tbl := range []string{
"monitor_probe_latest",
"monitor_probe_hour",
"monitor_probe_day",
"monitor_kv",
"monitor_checks",
"monitor_website_urls",
"monitor_website_groups",
"monitor_websites",
"monitor_groups",
} {
_ = db.Exec("TRUNCATE TABLE " + tbl).Error
}
_ = db.Exec("SET FOREIGN_KEY_CHECKS = 1").Error
log.Println("已清空 monitor_* 表")
}
websitesPath := filepath.Join(*dataDir, "websites.json")
raw, err := os.ReadFile(websitesPath)
if err != nil {
log.Fatalf("读取 websites.json: %v", err)
}
var websites []models.Website
if err := json.Unmarshal(raw, &websites); err != nil {
log.Fatal(err)
}
groupsPath := filepath.Join(*dataDir, "groups.json")
var fileGroups []models.Group
if g, err := os.ReadFile(groupsPath); err == nil {
_ = json.Unmarshal(g, &fileGroups)
}
if len(fileGroups) == 0 {
fileGroups = models.DefaultGroups
}
for i, g := range fileGroups {
if err := db.Create(&storage.MonitorGroup{
ID: g.ID, Name: g.Name, SortOrder: i + 1,
}).Error; err != nil {
log.Printf("导入分组 %s: %v", g.ID, err)
}
}
for _, w := range websites {
if len(w.Groups) == 0 && w.Group != "" {
w.Groups = []string{w.Group}
}
row := &storage.MonitorWebsite{
ID: w.ID,
Name: w.Name,
LegacyGroup: "",
Favicon: w.Favicon,
Title: w.Title,
IPAddresses: datatypes.JSON(mustJSON(w.IPAddresses)),
CreatedAt: w.CreatedAt,
UpdatedAt: w.UpdatedAt,
}
if err := db.Create(row).Error; err != nil {
log.Printf("网站 %s: %v", w.ID, err)
continue
}
for i, u := range w.URLs {
_ = db.Create(&storage.MonitorWebsiteURL{
WebsiteID: w.ID, URLID: u.ID, URL: u.URL, Remark: u.Remark, SortOrder: i,
})
}
for _, gid := range w.Groups {
_ = db.Create(&storage.MonitorWebsiteGroup{WebsiteID: w.ID, GroupID: gid})
}
}
fmt.Printf("已导入 %d 个网站\n", len(websites))
log.Println("探测历史由运行时写入 monitor_probe_* 汇总表，不再从 records.json 导入")
}
func mustJSON(v []string) []byte {
if v == nil {
return []byte("[]")
}
b, err := json.Marshal(v)
if err != nil {
return []byte("[]")
}
return b
}

269
mengyaping-backend/config/config.go
View File

@@ -1,176 +1,93 @@
package config
import (
"encoding/json"
"fmt"
"os"
"sync"
"time"
)
// Config 应用配置
type Config struct {
Server ServerConfig `json:"server"`
Monitor MonitorConfig `json:"monitor"`
DataPath string `json:"data_path"`
}
// ServerConfig 服务器配置
type ServerConfig struct {
Port string `json:"port"`
Host string `json:"host"`
}
// MonitorConfig 监控配置
type MonitorConfig struct {
Interval time.Duration `json:"interval"` // 检测间隔
Timeout time.Duration `json:"timeout"` // 请求超时时间
RetryCount int `json:"retry_count"` // 重试次数
HistoryDays int `json:"history_days"` // 保留历史天数
}
var (
cfg *Config
once sync.Once
)
// GetConfig 获取配置单例
func GetConfig() *Config {
once.Do(func() {
cfg = &Config{
Server: ServerConfig{
Port: getEnv("SERVER_PORT", "8080"),
Host: getEnv("SERVER_HOST", "0.0.0.0"),
},
Monitor: MonitorConfig{
Interval: parseDuration(getEnv("MONITOR_INTERVAL", "1h"), 1*time.Hour),
Timeout: parseDuration(getEnv("MONITOR_TIMEOUT", "10s"), 10*time.Second),
RetryCount: parseInt(getEnv("MONITOR_RETRY_COUNT", "3"), 3),
HistoryDays: parseInt(getEnv("MONITOR_HISTORY_DAYS", "90"), 90),
},
DataPath: getEnv("DATA_PATH", "./data"),
}
// 尝试从配置文件加载（会覆盖环境变量配置）
loadConfigFromFile()
})
return cfg
}
// getEnv 获取环境变量，如果不存在则返回默认值
func getEnv(key, defaultValue string) string {
if value := os.Getenv(key); value != "" {
return value
}
return defaultValue
}
// parseInt 解析整数环境变量
func parseInt(value string, defaultValue int) int {
if value == "" {
return defaultValue
}
var result int
if _, err := fmt.Sscanf(value, "%d", &result); err != nil {
return defaultValue
}
return result
}
// parseDuration 解析时间间隔环境变量
func parseDuration(value string, defaultValue time.Duration) time.Duration {
if value == "" {
return defaultValue
}
if duration, err := time.ParseDuration(value); err == nil {
return duration
}
return defaultValue
}
// loadConfigFromFile 从文件加载配置
func loadConfigFromFile() {
configFile := "./data/config.json"
if _, err := os.Stat(configFile); os.IsNotExist(err) {
return
}
data, err := os.ReadFile(configFile)
if err != nil {
return
}
var fileCfg struct {
Server ServerConfig `json:"server"`
Monitor struct {
IntervalMinutes int `json:"interval_minutes"`
TimeoutSeconds int `json:"timeout_seconds"`
RetryCount int `json:"retry_count"`
HistoryDays int `json:"history_days"`
} `json:"monitor"`
DataPath string `json:"data_path"`
}
if err := json.Unmarshal(data, &fileCfg); err != nil {
return
}
if fileCfg.Server.Port != "" {
cfg.Server.Port = fileCfg.Server.Port
}
if fileCfg.Server.Host != "" {
cfg.Server.Host = fileCfg.Server.Host
}
if fileCfg.Monitor.IntervalMinutes > 0 {
cfg.Monitor.Interval = time.Duration(fileCfg.Monitor.IntervalMinutes) * time.Minute
}
if fileCfg.Monitor.TimeoutSeconds > 0 {
cfg.Monitor.Timeout = time.Duration(fileCfg.Monitor.TimeoutSeconds) * time.Second
}
if fileCfg.Monitor.RetryCount > 0 {
cfg.Monitor.RetryCount = fileCfg.Monitor.RetryCount
}
if fileCfg.Monitor.HistoryDays > 0 {
cfg.Monitor.HistoryDays = fileCfg.Monitor.HistoryDays
}
if fileCfg.DataPath != "" {
cfg.DataPath = fileCfg.DataPath
}
}
// SaveConfig 保存配置到文件
func SaveConfig() error {
configFile := cfg.DataPath + "/config.json"
fileCfg := struct {
Server ServerConfig `json:"server"`
Monitor struct {
IntervalMinutes int `json:"interval_minutes"`
TimeoutSeconds int `json:"timeout_seconds"`
RetryCount int `json:"retry_count"`
HistoryDays int `json:"history_days"`
} `json:"monitor"`
DataPath string `json:"data_path"`
}{
Server: cfg.Server,
Monitor: struct {
IntervalMinutes int `json:"interval_minutes"`
TimeoutSeconds int `json:"timeout_seconds"`
RetryCount int `json:"retry_count"`
HistoryDays int `json:"history_days"`
}{
IntervalMinutes: int(cfg.Monitor.Interval.Minutes()),
TimeoutSeconds: int(cfg.Monitor.Timeout.Seconds()),
RetryCount: cfg.Monitor.RetryCount,
HistoryDays: cfg.Monitor.HistoryDays,
},
DataPath: cfg.DataPath,
}
data, err := json.MarshalIndent(fileCfg, "", " ")
if err != nil {
return err
}
return os.WriteFile(configFile, data, 0644)
}
package config
import (
"fmt"
"os"
"sync"
"time"
)
// Config 应用配置（持久化在 MySQL monitor_kv，首次启动前由环境变量提供默认值；MySQL 连接信息首次连接仍依赖环境变量/DB_DSN）
type Config struct {
Server ServerConfig `json:"server"`
Monitor MonitorConfig `json:"monitor"`
DataPath string `json:"data_path"`
Database DatabaseConfig `json:"database"`
}
// ServerConfig 服务器配置
type ServerConfig struct {
Port string `json:"port"`
Host string `json:"host"`
}
// MonitorConfig 监控配置
type MonitorConfig struct {
Interval time.Duration `json:"interval"` // 检测间隔
Timeout time.Duration `json:"timeout"` // 请求超时时间
RetryCount int `json:"retry_count"` // 重试次数
HistoryDays int `json:"history_days"` // 保留历史天数
}
var (
cfg *Config
once sync.Once
)
// GetConfig 获取配置单例（连接 MySQL 后由 storage 根据 monitor_kv 覆盖）
func GetConfig() *Config {
once.Do(func() {
cfg = &Config{
Server: ServerConfig{
Port: getEnv("SERVER_PORT", "8080"),
Host: getEnv("SERVER_HOST", "0.0.0.0"),
},
Monitor: MonitorConfig{
Interval: parseDuration(getEnv("MONITOR_INTERVAL", "30m"), 30*time.Minute),
Timeout: parseDuration(getEnv("MONITOR_TIMEOUT", "10s"), 10*time.Second),
RetryCount: parseInt(getEnv("MONITOR_RETRY_COUNT", "3"), 3),
HistoryDays: parseInt(getEnv("MONITOR_HISTORY_DAYS", "90"), 90),
},
DataPath: getEnv("DATA_PATH", "./data"),
Database: DatabaseConfig{
Host: getEnv("DB_HOST", "192.168.1.100"),
Port: getEnv("DB_PORT", "3306"),
User: getEnv("DB_USER", "mengyaping"),
Password: getEnv("DB_PASSWORD", "mengyaping"),
Database: getEnv("DB_NAME", "mengyaping"),
},
}
})
return cfg
}
// getEnv 获取环境变量，如果不存在则返回默认值
func getEnv(key, defaultValue string) string {
if value := os.Getenv(key); value != "" {
return value
}
return defaultValue
}
// parseInt 解析整数环境变量
func parseInt(value string, defaultValue int) int {
if value == "" {
return defaultValue
}
var result int
if _, err := fmt.Sscanf(value, "%d", &result); err != nil {
return defaultValue
}
return result
}
// parseDuration 解析时间间隔环境变量
func parseDuration(value string, defaultValue time.Duration) time.Duration {
if value == "" {
return defaultValue
}
if duration, err := time.ParseDuration(value); err == nil {
return duration
}
return defaultValue
}

25
mengyaping-backend/config/database.go Normal file
View File

@@ -0,0 +1,25 @@
package config
import (
"fmt"
"os"
)
// DatabaseConfig MySQL 连接（环境变量 DB_* 可覆盖；亦支持 DB_DSN 整串）
type DatabaseConfig struct {
Host string `json:"host"`
Port string `json:"port"`
User string `json:"user"`
Password string `json:"password"`
Database string `json:"database"`
}
// DatabaseDSN 返回 GORM/MySQL driver 用连接串
func (c *Config) DatabaseDSN() string {
if dsn := os.Getenv("DB_DSN"); dsn != "" {
return dsn
}
d := c.Database
return fmt.Sprintf("%s:%s@tcp(%s:%s)/%s?charset=utf8mb4&parseTime=True&loc=Local",
d.User, d.Password, d.Host, d.Port, d.Database)
}

38
mengyaping-backend/config/monitor_interval.go Normal file
View File

@@ -0,0 +1,38 @@
package config
import "slices"
// AllowedMonitorIntervalMinutes 后台预设的全局检测周期（分钟）
var AllowedMonitorIntervalMinutes = []int{10, 20, 30, 60, 180, 360}
// IsAllowedMonitorInterval 是否为允许的检测间隔（分钟）
func IsAllowedMonitorInterval(minutes int) bool {
return minutes > 0 && slices.Contains(AllowedMonitorIntervalMinutes, minutes)
}
// SnapMonitorIntervalMinutes 将分钟数裁剪到最近的预设值（用于读取旧配置）
func SnapMonitorIntervalMinutes(minutes int) int {
if minutes <= 0 {
return 30
}
if IsAllowedMonitorInterval(minutes) {
return minutes
}
best := AllowedMonitorIntervalMinutes[0]
bestDist := absInt(minutes - best)
for _, v := range AllowedMonitorIntervalMinutes[1:] {
d := absInt(minutes - v)
if d < bestDist {
bestDist = d
best = v
}
}
return best
}
func absInt(x int) int {
if x < 0 {
return -x
}
return x
}

24
mengyaping-backend/config/monitor_interval_test.go Normal file
View File

@@ -0,0 +1,24 @@
package config
import "testing"
func TestIsAllowedMonitorInterval(t *testing.T) {
if !IsAllowedMonitorInterval(10) || !IsAllowedMonitorInterval(360) {
t.Fatal("expected 10 and 360 allowed")
}
if IsAllowedMonitorInterval(5) || IsAllowedMonitorInterval(45) {
t.Fatal("expected 5 and 45 disallowed")
}
}
func TestSnapMonitorIntervalMinutes(t *testing.T) {
if SnapMonitorIntervalMinutes(5) != 10 {
t.Fatalf("5 -> 10, got %d", SnapMonitorIntervalMinutes(5))
}
if SnapMonitorIntervalMinutes(7) != 10 {
t.Fatalf("7 -> 10, got %d", SnapMonitorIntervalMinutes(7))
}
if SnapMonitorIntervalMinutes(25) != 20 {
t.Fatalf("25 -> 20, got %d", SnapMonitorIntervalMinutes(25))
}
}

0
mengyaping-backend/data/.gitkeep Normal file
View File

13
mengyaping-backend/data/config.json
View File

@@ -1,13 +0,0 @@
{
"server": {
"port": "8080",
"host": "0.0.0.0"
},
"monitor": {
"interval_minutes": 5,
"timeout_seconds": 10,
"retry_count": 3,
"history_days": 7
},
"data_path": "./data"
}

18
mengyaping-backend/data/groups.json
View File

@@ -1,18 +0,0 @@
[
{
"id": "self-made",
"name": "自制网站"
},
{
"id": "self-deploy",
"name": "自部署网站"
},
{
"id": "admin",
"name": "管理员网站"
},
{
"id": "api",
"name": "API网站"
}
]

9735
mengyaping-backend/data/records.json
View File

File diff suppressed because it is too large Load Diff

821
mengyaping-backend/data/websites.json
View File

@@ -1,821 +0,0 @@
[
{
"id": "188cb48c619bd5d896bff546",
"name": "萌芽主页",
"groups": [
"self-made"
],
"urls": [
{
"id": "d19b0a475334",
"url": "https://shumengya.top",
"remark": ""
}
],
"ip_addresses": [
"47.108.228.23"
],
"favicon": "https://shumengya.top/favicon.ico",
"title": "萌芽主页",
"created_at": "2026-01-21T17:21:08.6757862+08:00",
"updated_at": "2026-03-06T13:12:33.6663492+08:00"
},
{
"id": "188cb49298d72b78a37301a1",
"name": "萌芽备忘录",
"groups": [
"self-deploy"
],
"urls": [
{
"id": "9d25ae024f36",
"url": "https://memos.shumengya.top",
"remark": ""
}
],
"ip_addresses": [
"47.108.228.23"
],
"favicon": "https://memos.shumengya.top/logo.webp",
"title": "Memos",
"created_at": "2026-01-21T17:21:35.3722254+08:00",
"updated_at": "2026-03-06T13:12:34.4657931+08:00"
},
{
"id": "188cb52c04cf639cfc2c8ba4",
"name": "萌芽盘",
"groups": [
"self-deploy"
],
"urls": [
{
"id": "cfe6229fb86b",
"url": "https://pan.shumengya.top",
"remark": ""
}
],
"ip_addresses": [
"47.108.228.23"
],
"favicon": "https://img.shumengya.top/i/2026/01/04/695a660870959.png",
"title": "萌芽盘",
"created_at": "2026-01-21T17:32:34.3136511+08:00",
"updated_at": "2026-03-06T13:12:35.6184204+08:00"
},
{
"id": "188cb53623f46b7872bf17b6",
"name": "萌芽Git仓库",
"groups": [
"self-deploy"
],
"urls": [
{
"id": "b53594e7285d",
"url": "https://git.shumengya.top",
"remark": ""
}
],
"ip_addresses": [
"47.108.228.23"
],
"favicon": "https://git.shumengya.top/assets/img/favicon.svg",
"title": "萌芽Git仓库",
"created_at": "2026-01-21T17:33:17.7858446+08:00",
"updated_at": "2026-03-06T13:12:36.4115003+08:00"
},
{
"id": "188cb54b93ddd1e487bf347e",
"name": "萌芽图床",
"groups": [
"self-deploy"
],
"urls": [
{
"id": "46d822694242",
"url": "https://image.shumengya.top",
"remark": ""
}
],
"ip_addresses": [
"47.108.228.23"
],
"favicon": "https://image.shumengya.top/favicon.ico",
"title": "萌芽图床",
"created_at": "2026-01-21T17:34:49.8577249+08:00",
"updated_at": "2026-03-06T13:12:38.40321+08:00"
},
{
"id": "188cb5507dcd2da0559bd6dd",
"name": "萌芽笔记",
"groups": [
"self-made"
],
"urls": [
{
"id": "6d5125db9d81",
"url": "https://note.shumengya.top",
"remark": ""
}
],
"ip_addresses": [
"47.108.228.23"
],
"favicon": "https://note.shumengya.top/logo.png",
"title": "萌芽笔记",
"created_at": "2026-01-21T17:35:10.962372+08:00",
"updated_at": "2026-03-06T13:12:40.1738642+08:00"
},
{
"id": "188cb55693193b80d2383cc3",
"name": "萌芽作品集",
"groups": [
"self-made"
],
"urls": [
{
"id": "74a3b6e1f50e",
"url": "https://work.shumengya.top",
"remark": ""
}
],
"ip_addresses": [
"47.108.228.23"
],
"favicon": "https://work.shumengya.top/favicon.ico",
"title": "502 Bad Gateway",
"created_at": "2026-01-21T17:35:37.0894816+08:00",
"updated_at": "2026-03-06T13:12:40.976149+08:00"
},
{
"id": "188cb56d8df57dc8c66d42ee",
"name": "万象口袋",
"groups": [
"self-made"
],
"urls": [
{
"id": "e8f8fd4cf9b9",
"url": "https://infogenie.shumengya.top",
"remark": ""
}
],
"ip_addresses": [
"47.108.228.23"
],
"favicon": "https://infogenie.shumengya.top/assets/logo.png",
"title": "万象口袋",
"created_at": "2026-01-21T17:37:15.787501+08:00",
"updated_at": "2026-03-06T13:12:42.7325255+08:00"
},
{
"id": "188cb574b122f71087e53ae1",
"name": "萌芽问卷",
"groups": [
"self-deploy"
],
"urls": [
{
"id": "2f9ffdedd860",
"url": "https://survey.shumengya.top",
"remark": ""
}
],
"ip_addresses": [
"47.108.228.23"
],
"favicon": "https://survey.shumengya.top/favicon.ico",
"title": "502 Bad Gateway",
"created_at": "2026-01-21T17:37:46.4424548+08:00",
"updated_at": "2026-03-06T13:12:44.9725726+08:00"
},
{
"id": "188cb5a19b836e80d93df86a",
"name": "萌芽短链",
"groups": [
"self-made"
],
"urls": [
{
"id": "8a4ebcb7eb03",
"url": "https://short.shumengya.top",
"remark": ""
}
],
"ip_addresses": [
"47.108.228.23"
],
"favicon": "https://short.shumengya.top/logo.png",
"title": "萌芽短链",
"created_at": "2026-01-21T17:40:59.3532064+08:00",
"updated_at": "2026-03-06T13:12:45.7693627+08:00"
},
{
"id": "188cb6da20586d34df88b086",
"name": "萌芽漂流瓶",
"groups": [
"self-made"
],
"urls": [
{
"id": "e7e250eb8985",
"url": "https://bottle.shumengya.top",
"remark": ""
}
],
"ip_addresses": [
"47.108.228.23"
],
"favicon": "https://bottle.shumengya.top/logo.png",
"title": "萌芽漂流瓶(´,,•ω•,,)♡",
"created_at": "2026-01-21T18:03:21.6115541+08:00",
"updated_at": "2026-03-06T13:12:46.5656927+08:00"
},
{
"id": "188cb6ff716e2590408704ee",
"name": "编程速查表[CloudFlare]",
"groups": [
"self-deploy"
],
"urls": [
{
"id": "85620784f1a3",
"url": "https://reference.smyhub.com",
"remark": ""
}
],
"ip_addresses": [
"188.114.96.0",
"188.114.97.0",
"2a06:98c1:3121::",
"2a06:98c1:3120::"
],
"favicon": "https://reference.smyhub.com/icons/favicon.svg",
"title": "Quick Reference\n \u0026#x26; Quick Reference",
"created_at": "2026-01-21T18:06:01.885722+08:00",
"updated_at": "2026-03-06T13:12:48.1727895+08:00"
},
{
"id": "188cb708e8cf52a49a436570",
"name": "思绪思维导图[CloudFlare]",
"groups": [
"self-deploy"
],
"urls": [
{
"id": "dcc07e30a25a",
"url": "https://mind-map.smyhub.com",
"remark": ""
}
],
"favicon": "https://mind-map.smyhub.com/dist/logo.ico",
"title": "思绪思维导图",
"created_at": "2026-01-21T18:06:42.5432849+08:00",
"updated_at": "2026-01-27T13:10:46.0879149+08:00"
},
{
"id": "188cb71029ad43105a3dc6c0",
"name": "it-tools工具集[CloudFlare]",
"groups": [
"self-deploy"
],
"urls": [
{
"id": "f278e65dd498",
"url": "https://it-tools.smyhub.com",
"remark": ""
}
],
"ip_addresses": [
"188.114.97.0",
"188.114.96.0",
"2a06:98c1:3121::",
"2a06:98c1:3120::"
],
"favicon": "https://it-tools.smyhub.com/favicon.ico",
"title": "IT Tools - Handy online tools for developers",
"created_at": "2026-01-21T18:07:13.6963428+08:00",
"updated_at": "2026-03-06T13:12:49.7591315+08:00"
},
{
"id": "188cb71b527c48bc3c344acc",
"name": "xtools工具集[CloudFlare]",
"groups": [
"self-deploy"
],
"urls": [
{
"id": "13cdc2afab17",
"url": "https://xtools.smyhub.com",
"remark": ""
}
],
"ip_addresses": [
"188.114.96.0",
"188.114.97.0",
"2a06:98c1:3121::",
"2a06:98c1:3120::"
],
"favicon": "https://xtools.smyhub.com/favicon.ico",
"title": "百川云常用工具",
"created_at": "2026-01-21T18:08:01.6256391+08:00",
"updated_at": "2026-03-06T13:12:52.8447254+08:00"
},
{
"id": "188cb72555e8d5c4f0d7aa98",
"name": "萌芽监控面板",
"groups": [
"admin"
],
"urls": [
{
"id": "421fe08ece5e",
"url": "http://monitor.shumengya.top",
"remark": ""
}
],
"ip_addresses": [
"47.108.228.23"
],
"favicon": "http://monitor.shumengya.top/logo.png",
"title": "萌芽监控面板",
"created_at": "2026-01-21T18:08:44.6327577+08:00",
"updated_at": "2026-03-06T13:12:53.6453208+08:00"
},
{
"id": "188cb73272be1c9c5a5d6812",
"name": "在线office",
"groups": [
"self-deploy"
],
"urls": [
{
"id": "cba98c3c329b",
"url": "https://office.shumengya.top",
"remark": ""
}
],
"ip_addresses": [
"47.108.228.23"
],
"favicon": "https://office.shumengya.top/favicon.ico",
"title": "404 Not Found",
"created_at": "2026-01-21T18:09:40.9510719+08:00",
"updated_at": "2026-03-06T13:12:54.436477+08:00"
},
{
"id": "188cb7372655f3841e82a210",
"name": "网页魔方[CloudFlare]",
"groups": [
"self-deploy"
],
"urls": [
{
"id": "ed4c7dcd0565",
"url": "https://cube.smyhub.com",
"remark": ""
}
],
"favicon": "https://cube.smyhub.com/favicon.ico",
"title": "HTML5 3D魔方小游戏",
"created_at": "2026-01-21T18:10:01.1440137+08:00",
"updated_at": "2026-01-27T13:12:55.4496439+08:00"
},
{
"id": "188cb764a98dbb2453c14b8f",
"name": "60sAPI集合",
"groups": [
"api"
],
"urls": [
{
"id": "2f0596587997",
"url": "https://60s.api.shumengya.top",
"remark": ""
}
],
"ip_addresses": [
"47.108.228.23"
],
"favicon": "https://60s.api.shumengya.top/favicon.ico",
"title": "502 Bad Gateway",
"created_at": "2026-01-21T18:13:16.6194034+08:00",
"updated_at": "2026-03-06T13:12:56.3727134+08:00"
},
{
"id": "188cb77f231fe68c73e24b29",
"name": "萌芽主页后端API",
"groups": [
"api"
],
"urls": [
{
"id": "c182709178d9",
"url": "https://nav.api.shumengya.top",
"remark": ""
}
],
"ip_addresses": [
"47.108.228.23"
],
"favicon": "https://nav.api.shumengya.top/favicon.ico",
"title": "502 Bad Gateway",
"created_at": "2026-01-21T18:15:10.3277851+08:00",
"updated_at": "2026-03-06T13:12:57.5163074+08:00"
},
{
"id": "188cb789a76896788f139a96",
"name": "萌芽笔记后端API",
"groups": [
"api"
],
"urls": [
{
"id": "2b42ed612dd3",
"url": "https://note.api.shumengya.top/api/tree",
"remark": ""
}
],
"ip_addresses": [
"47.108.228.23"
],
"favicon": "https://note.api.shumengya.top/favicon.ico",
"title": "502 Bad Gateway",
"created_at": "2026-01-21T18:15:55.4968142+08:00",
"updated_at": "2026-03-06T13:12:58.307067+08:00"
},
{
"id": "188cb7934d5d413890dea61f",
"name": "萌芽作品集后端API",
"groups": [
"api"
],
"urls": [
{
"id": "d841646c7b41",
"url": "https://work.api.shumengya.top",
"remark": ""
}
],
"ip_addresses": [
"47.108.228.23"
],
"favicon": "https://work.api.shumengya.top/favicon.ico",
"title": "502 Bad Gateway",
"created_at": "2026-01-21T18:16:36.935795+08:00",
"updated_at": "2026-03-06T13:12:59.0980222+08:00"
},
{
"id": "188cb79ed2aeb85cabcf6e66",
"name": "万象口袋后端API",
"groups": [
"api"
],
"urls": [
{
"id": "7c8ff0e48be4",
"url": "https://infogenie.api.shumengya.top",
"remark": ""
}
],
"ip_addresses": [
"47.108.228.23"
],
"favicon": "https://infogenie.api.shumengya.top/favicon.ico",
"title": "502 Bad Gateway",
"created_at": "2026-01-21T18:17:26.4171439+08:00",
"updated_at": "2026-03-06T13:12:59.8921428+08:00"
},
{
"id": "188cb7b7b154ddbc1dc4b14d",
"name": "萌芽短链后端API",
"groups": [
"api"
],
"urls": [
{
"id": "ef0443476dd8",
"url": "https://short.api.shumengya.top",
"remark": ""
}
],
"ip_addresses": [
"47.108.228.23"
],
"favicon": "https://short.api.shumengya.top/favicon.ico",
"title": "502 Bad Gateway",
"created_at": "2026-01-21T18:19:13.2317895+08:00",
"updated_at": "2026-03-06T13:13:02.3005616+08:00"
},
{
"id": "188cb7c8586dd2c4dcf4bd1e",
"name": "萌芽漂流瓶后端API",
"groups": [
"api"
],
"urls": [
{
"id": "432740a25595",
"url": "https://bottle.api.shumengya.top",
"remark": ""
}
],
"ip_addresses": [
"47.108.228.23"
],
"favicon": "https://bottle.api.shumengya.top/favicon.ico",
"title": "502 Bad Gateway",
"created_at": "2026-01-21T18:20:24.7546969+08:00",
"updated_at": "2026-03-06T13:13:03.0940218+08:00"
},
{
"id": "188cf6ed769b75e497cd2a4a",
"name": "大萌芽1Panel面板[WG]",
"groups": [
"admin"
],
"urls": [
{
"id": "a3e3ff7839f1",
"url": "http://10.0.0.233:19132/smy",
"remark": ""
}
],
"ip_addresses": [
"10.0.0.233"
],
"favicon": "http://10.0.0.233:19132/favicon.ico",
"title": "loading...",
"created_at": "2026-01-22T13:37:33.4073441+08:00",
"updated_at": "2026-03-06T13:13:03.5972427+08:00"
},
{
"id": "188cf6f322f76b90c35c3484",
"name": "小萌芽1Panel面板[WG]",
"groups": [
"admin"
],
"urls": [
{
"id": "76b6f9fe4f04",
"url": "http://10.0.0.100:19132/smy",
"remark": ""
}
],
"ip_addresses": [
"10.0.0.100"
],
"favicon": "http://10.0.0.100:19132/favicon.ico",
"title": "loading...",
"created_at": "2026-01-22T13:37:57.7738884+08:00",
"updated_at": "2026-03-06T13:13:04.1047503+08:00"
},
{
"id": "188cf7019e56e618827f4927",
"name": "大萌芽Portaintor面板[WG]",
"groups": [
"admin"
],
"urls": [
{
"id": "093d47789bb5",
"url": "http://10.0.0.233:8484/",
"remark": ""
}
],
"ip_addresses": [
"10.0.0.233"
],
"favicon": "http://10.0.0.233:8484/dd5d4c0b208895c5a7de.png",
"title": "Portainer",
"created_at": "2026-01-22T13:38:59.9732854+08:00",
"updated_at": "2026-03-06T13:13:04.6105552+08:00"
},
{
"id": "188cf70700922fa4041f6470",
"name": "小萌芽Portaintor面板[WG]",
"groups": [
"admin"
],
"urls": [
{
"id": "777c292c7696",
"url": "http://10.0.0.100:8484/",
"remark": ""
}
],
"ip_addresses": [
"10.0.0.100"
],
"favicon": "http://10.0.0.100:8484/dd5d4c0b208895c5a7de.png",
"title": "Portainer",
"created_at": "2026-01-22T13:39:23.0961745+08:00",
"updated_at": "2026-03-06T13:13:05.112894+08:00"
},
{
"id": "188cf728ed2992f06a8f9e52",
"name": "easytier面板",
"groups": [
"admin"
],
"urls": [
{
"id": "0a0a59069228",
"url": "http://easytier.shumengya.top",
"remark": ""
}
],
"ip_addresses": [
"47.108.228.23"
],
"favicon": "http://easytier.shumengya.top/easytier.png",
"title": "EasyTier Dashboard",
"created_at": "2026-01-22T13:41:48.7994396+08:00",
"updated_at": "2026-03-06T13:13:06.2605727+08:00"
},
{
"id": "188cf72edea71c4cb2284c93",
"name": "wireguard面板",
"groups": [
"admin"
],
"urls": [
{
"id": "170fab2239ad",
"url": "https://wireguard.shumengya.top",
"remark": ""
}
],
"ip_addresses": [
"47.108.228.23"
],
"favicon": "https://wireguard.shumengya.top/favicon.ico",
"title": "502 Bad Gateway",
"created_at": "2026-01-22T13:42:14.3258123+08:00",
"updated_at": "2026-03-06T13:13:07.8283939+08:00"
},
{
"id": "188cf746b16a83dc4d5e3d13",
"name": "萌芽Docker镜像仓库",
"groups": [
"admin"
],
"urls": [
{
"id": "822329e621c2",
"url": "https://repo.docker.shumengya.top",
"remark": ""
}
],
"favicon": "https://repo.docker.shumengya.top/favicon.ico",
"title": "502 Bad Gateway",
"created_at": "2026-01-22T13:43:56.6460815+08:00",
"updated_at": "2026-01-26T11:56:40.972109897+08:00"
},
{
"id": "188cf74b2fa5da7c8e2b588e",
"name": "萌芽通知",
"groups": [
"admin"
],
"urls": [
{
"id": "2f580f90f979",
"url": "https://notice.shumengya.top",
"remark": ""
}
],
"ip_addresses": [
"47.108.228.23"
],
"favicon": "https://notice.shumengya.top/favicon.ico",
"title": "萌芽监控面板",
"created_at": "2026-01-22T13:44:15.9437687+08:00",
"updated_at": "2026-03-06T13:13:09.4168617+08:00"
},
{
"id": "188d00db054cf7860dff3440",
"name": "萌芽Ping",
"groups": [
"admin"
],
"urls": [
{
"id": "ac85b166ccc4",
"url": "https://ping.shumengya.top",
"remark": ""
}
],
"ip_addresses": [
"47.108.228.23"
],
"favicon": "https://ping.shumengya.top/favicon.ico",
"title": "萌芽Ping - 网站监控面板",
"created_at": "2026-01-22T16:39:29.31324815+08:00",
"updated_at": "2026-03-06T13:13:10.213788+08:00"
},
{
"id": "188d00edf571226f42ec8b20",
"name": "萌芽Ping后端API",
"groups": [
"api"
],
"urls": [
{
"id": "0bf0fe1bb9cc",
"url": "https://ping.api.shumengya.top",
"remark": ""
}
],
"ip_addresses": [
"47.108.228.23"
],
"favicon": "https://ping.api.shumengya.top/favicon.ico",
"title": "萌芽Git仓库",
"created_at": "2026-01-22T16:40:50.651561641+08:00",
"updated_at": "2026-03-06T13:13:11.3565622+08:00"
},
{
"id": "188e7f1a40cdc7bc3bba1817",
"name": "DNS查询[CloudFlare]",
"groups": [
"self-deploy"
],
"urls": [
{
"id": "9af024b3d387",
"url": "https://cf-dns.smyhub.com/",
"remark": ""
}
],
"ip_addresses": [
"188.114.97.0",
"188.114.96.0",
"2a06:98c1:3121::",
"2a06:98c1:3120::"
],
"favicon": "https://cf-assets.www.cloudflare.com/dzlvafdwdttg/6TaQ8Q7BDmdAFRoHpDCb82/8d9bc52a2ac5af100de3a9adcf99ffaa/security-shield-protection-2.svg",
"title": "DNS-over-HTTPS Resolver",
"created_at": "2026-01-27T13:24:14.3362887+08:00",
"updated_at": "2026-03-06T13:13:12.1501803+08:00"
},
{
"id": "188e7f27a909fe247a2fcd15",
"name": "Github文件加速[CloudFlare]",
"groups": [
"self-deploy"
],
"urls": [
{
"id": "b897ef0def67",
"url": "https://gh-proxy.smyhub.com/",
"remark": ""
}
],
"ip_addresses": [
"188.114.97.0",
"188.114.96.0",
"2a06:98c1:3121::",
"2a06:98c1:3120::"
],
"favicon": "https://gh-proxy.smyhub.com/favicon.ico",
"title": "GitHub 文件加速",
"created_at": "2026-01-27T13:25:11.9196401+08:00",
"updated_at": "2026-03-06T13:13:12.9476294+08:00"
},
{
"id": "188e7f33f087667c29da05f2",
"name": "FloppyBird[CloudFlare]",
"groups": [
"self-deploy"
],
"urls": [
{
"id": "75a0cb223c2d",
"url": "https://floppy-bird.smyhub.com/",
"remark": ""
}
],
"favicon": "https://floppy-bird.smyhub.com/favicon.ico",
"title": "Floppy Bird",
"created_at": "2026-01-27T13:26:04.6586487+08:00",
"updated_at": "2026-01-27T13:26:05.4749231+08:00"
},
{
"id": "188e7f4cdd13a3bc80c68184",
"name": "别踩白方块[CloudFlare]",
"groups": [
"self-deploy"
],
"urls": [
{
"id": "9f11daaedba4",
"url": "https://floppy-bird.smyhub.com/",
"remark": ""
}
],
"favicon": "https://floppy-bird.smyhub.com/favicon.ico",
"title": "Floppy Bird",
"created_at": "2026-01-27T13:27:51.7064775+08:00",
"updated_at": "2026-01-27T13:27:51.9331276+08:00"
}
]

8
mengyaping-backend/docker-compose.yml
View File

@@ -1,3 +1,5 @@
# 生产：先在 Windows 运行 build-linux-amd64.bat 生成 dist/mengyaping-backend，再 docker compose build（镜像内不再编译 Go）
# 若需在服务器上用源码构建镜像：docker build -f Dockerfile.source -t mengyaping-backend:source .
version: '3.8'
services:
@@ -16,11 +18,13 @@ services:
# 服务器配置
- SERVER_PORT=8080
- SERVER_HOST=0.0.0.0
# 监控配置
- MONITOR_INTERVAL=5m
# 监控默认值（首次写入 MySQL monitor_kv；周期也可在管理后台改，须为 10/20/30/60/180/360 分钟之一）
- MONITOR_INTERVAL=30m
- MONITOR_TIMEOUT=10s
- MONITOR_RETRY_COUNT=3
- MONITOR_HISTORY_DAYS=7
# 若设置则覆盖数据库 monitor_kv 中的 admin_token（部署密文推荐用环境变量）
- ADMIN_TOKEN=shumengya520
networks:
- mengyaping-network
healthcheck:

8
mengyaping-backend/go.mod
View File

@@ -5,9 +5,13 @@ go 1.25.0
require (
github.com/gin-contrib/cors v1.7.6
github.com/gin-gonic/gin v1.11.0
gorm.io/datatypes v1.2.4
gorm.io/driver/mysql v1.5.7
gorm.io/gorm v1.25.12
)
require (
filippo.io/edwards25519 v1.1.0 // indirect
github.com/bytedance/sonic v1.14.0 // indirect
github.com/bytedance/sonic/loader v0.3.0 // indirect
github.com/cloudwego/base64x v0.1.6 // indirect
@@ -16,8 +20,12 @@ require (
github.com/go-playground/locales v0.14.1 // indirect
github.com/go-playground/universal-translator v0.18.1 // indirect
github.com/go-playground/validator/v10 v10.27.0 // indirect
github.com/go-sql-driver/mysql v1.8.1 // indirect
github.com/goccy/go-json v0.10.5 // indirect
github.com/goccy/go-yaml v1.18.0 // indirect
github.com/google/uuid v1.3.0 // indirect
github.com/jinzhu/inflection v1.0.0 // indirect
github.com/jinzhu/now v1.1.5 // indirect
github.com/json-iterator/go v1.1.12 // indirect
github.com/klauspost/cpuid/v2 v2.3.0 // indirect
github.com/leodido/go-urn v1.4.0 // indirect

40
mengyaping-backend/go.sum
View File

@@ -1,3 +1,5 @@
filippo.io/edwards25519 v1.1.0 h1:FNf4tywRC1HmFuKW5xopWpigGjJKiJSV0Cqo0cJWDaA=
filippo.io/edwards25519 v1.1.0/go.mod h1:BxyFTGdWcka3PhytdK4V28tE5sGfRvvvRV7EaN4VDT4=
github.com/bytedance/sonic v1.14.0 h1:/OfKt8HFw0kh2rj8N0F6C/qPGRESq0BbaNZgcNXXzQQ=
github.com/bytedance/sonic v1.14.0/go.mod h1:WoEbx8WTcFJfzCe0hbmyTGrfjt8PzNEBdxlNUO24NhA=
github.com/bytedance/sonic/loader v0.3.0 h1:dskwH8edlzNMctoruo8FPTJDF3vLtDT0sXZwvZJyqeA=
@@ -23,13 +25,34 @@ github.com/go-playground/universal-translator v0.18.1 h1:Bcnm0ZwsGyWbCzImXv+pAJn
github.com/go-playground/universal-translator v0.18.1/go.mod h1:xekY+UJKNuX9WP91TpwSH2VMlDf28Uj24BCp08ZFTUY=
github.com/go-playground/validator/v10 v10.27.0 h1:w8+XrWVMhGkxOaaowyKH35gFydVHOvC0/uWoy2Fzwn4=
github.com/go-playground/validator/v10 v10.27.0/go.mod h1:I5QpIEbmr8On7W0TktmJAumgzX4CA1XNl4ZmDuVHKKo=
github.com/go-sql-driver/mysql v1.7.0/go.mod h1:OXbVy3sEdcQ2Doequ6Z5BW6fXNQTmx+9S1MCJN5yJMI=
github.com/go-sql-driver/mysql v1.8.1 h1:LedoTUt/eveggdHS9qUFC1EFSa8bU2+1pZjSRpvNJ1Y=
github.com/go-sql-driver/mysql v1.8.1/go.mod h1:wEBSXgmK//2ZFJyE+qWnIsVGmvmEKlqwuVSjsCm7DZg=
github.com/goccy/go-json v0.10.5 h1:Fq85nIqj+gXn/S5ahsiTlK3TmC85qgirsdTP/+DeaC4=
github.com/goccy/go-json v0.10.5/go.mod h1:oq7eo15ShAhp70Anwd5lgX2pLfOS3QCiwU/PULtXL6M=
github.com/goccy/go-yaml v1.18.0 h1:8W7wMFS12Pcas7KU+VVkaiCng+kG8QiFeFwzFb+rwuw=
github.com/goccy/go-yaml v1.18.0/go.mod h1:XBurs7gK8ATbW4ZPGKgcbrY1Br56PdM69F7LkFRi1kA=
github.com/golang-sql/civil v0.0.0-20220223132316-b832511892a9 h1:au07oEsX2xN0ktxqI+Sida1w446QrXBRJ0nee3SNZlA=
github.com/golang-sql/civil v0.0.0-20220223132316-b832511892a9/go.mod h1:8vg3r2VgvsThLBIFL93Qb5yWzgyZWhEmBwUJWevAkK0=
github.com/golang-sql/sqlexp v0.1.0 h1:ZCD6MBpcuOVfGVqsEmY5/4FtYiKz6tSyUv9LPEDei6A=
github.com/golang-sql/sqlexp v0.1.0/go.mod h1:J4ad9Vo8ZCWQ2GMrC4UCQy1JpCbwU9m3EOqtpKwwwHI=
github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
github.com/google/uuid v1.3.0 h1:t6JiXgmwXMjEs8VusXIJk2BXHsn+wx8BZdTaoZ5fu7I=
github.com/google/uuid v1.3.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsIM=
github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg=
github.com/jackc/pgservicefile v0.0.0-20231201235250-de7065d80cb9 h1:L0QtFUgDarD7Fpv9jeVMgy/+Ec0mtnmYuImjTz6dtDA=
github.com/jackc/pgservicefile v0.0.0-20231201235250-de7065d80cb9/go.mod h1:5TJZWKEWniPve33vlWYSoGYefn3gLQRzjfDlhSJ9ZKM=
github.com/jackc/pgx/v5 v5.5.5 h1:amBjrZVmksIdNjxGW/IiIMzxMKZFelXbUoPNb+8sjQw=
github.com/jackc/pgx/v5 v5.5.5/go.mod h1:ez9gk+OAat140fv9ErkZDYFWmXLfV+++K0uAOiwgm1A=
github.com/jackc/puddle/v2 v2.2.1 h1:RhxXJtFG022u4ibrCSMSiu5aOq1i77R3OHKNJj77OAk=
github.com/jackc/puddle/v2 v2.2.1/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4=
github.com/jinzhu/inflection v1.0.0 h1:K317FqzuhWc8YvSVlFMCCUb36O/S9MCKRDI7QkRKD/E=
github.com/jinzhu/inflection v1.0.0/go.mod h1:h+uFLlag+Qp1Va5pdKtLDYj+kHp5pxUVkryuEj+Srlc=
github.com/jinzhu/now v1.1.5 h1:/o9tlHleP7gOFmsnYNz3RGnqzefHA47wQpKrrdTIwXQ=
github.com/jinzhu/now v1.1.5/go.mod h1:d3SSVoowX0Lcu0IBviAWJpolVfI5UJVZZ7cO71lE/z8=
github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM=
github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo=
github.com/klauspost/cpuid/v2 v2.3.0 h1:S4CRMLnYUhGeDFDqkGriYKdfoFlDnMtqTiI/sFzhA9Y=
@@ -38,6 +61,10 @@ github.com/leodido/go-urn v1.4.0 h1:WT9HwE9SGECu3lg4d/dIA+jxlljEa1/ffXKmRjqdmIQ=
github.com/leodido/go-urn v1.4.0/go.mod h1:bvxc+MVxLKB4z00jd1z+Dvzr47oO32F/QSNjSBOlFxI=
github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
github.com/mattn/go-sqlite3 v1.14.15 h1:vfoHhTN1af61xCRSWzFIWzx2YskyMTwHLrExkBOjvxI=
github.com/mattn/go-sqlite3 v1.14.15/go.mod h1:2eHXhiwb8IkHr+BDWZGa96P6+rkvnG63S2DGjv9HUNg=
github.com/microsoft/go-mssqldb v0.17.0 h1:Fto83dMZPnYv1Zwx5vHHxpNraeEaUlQ/hhHLgZiaenE=
github.com/microsoft/go-mssqldb v0.17.0/go.mod h1:OkoNGhGEs8EZqchVTtochlXruEhEOaO4S0d2sB5aeGQ=
github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg=
github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
@@ -89,3 +116,16 @@ gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8
gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
gorm.io/datatypes v1.2.4 h1:uZmGAcK/QZ0uyfCuVg0VQY1ZmV9h1fuG0tMwKByO1z4=
gorm.io/datatypes v1.2.4/go.mod h1:f4BsLcFAX67szSv8svwLRjklArSHAvHLeE3pXAS5DZI=
gorm.io/driver/mysql v1.5.7 h1:MndhOPYOfEp2rHKgkZIhJ16eVUIRf2HmzgoPmh7FCWo=
gorm.io/driver/mysql v1.5.7/go.mod h1:sEtPWMiqiN1N1cMXoXmBbd8C6/l+TESwriotuRRpkDM=
gorm.io/driver/postgres v1.5.0 h1:u2FXTy14l45qc3UeCJ7QaAXZmZfDDv0YrthvmRq1l0U=
gorm.io/driver/postgres v1.5.0/go.mod h1:FUZXzO+5Uqg5zzwzv4KK49R8lvGIyscBOqYrtI1Ce9A=
gorm.io/driver/sqlite v1.4.3 h1:HBBcZSDnWi5BW3B3rwvVTc510KGkBkexlOg0QrmLUuU=
gorm.io/driver/sqlite v1.4.3/go.mod h1:0Aq3iPO+v9ZKbcdiz8gLWRw5VOPcBOPUQJFLq5e2ecI=
gorm.io/driver/sqlserver v1.4.1 h1:t4r4r6Jam5E6ejqP7N82qAJIJAht27EGT41HyPfXRw0=
gorm.io/driver/sqlserver v1.4.1/go.mod h1:DJ4P+MeZbc5rvY58PnmN1Lnyvb5gw5NPzGshHDnJLig=
gorm.io/gorm v1.25.7/go.mod h1:hbnx/Oo0ChWMn1BIhpy1oYozzpM15i4YPuHDmfYtwg8=
gorm.io/gorm v1.25.12 h1:I0u8i2hWQItBq1WfE0o2+WuL9+8L21K9e2HHSTE/0f8=
gorm.io/gorm v1.25.12/go.mod h1:xh7N7RHfYlNc5EmcI/El95gXusucDrQnHXe0+CgWcLQ=

87
mengyaping-backend/handlers/settings.go Normal file
View File

@@ -0,0 +1,87 @@
package handlers
import (
"net/http"
"github.com/gin-gonic/gin"
"mengyaping-backend/config"
"mengyaping-backend/models"
"mengyaping-backend/services"
"mengyaping-backend/storage"
)
// SettingsHandler 监控与系统配置（公开可读、管理端可写）
type SettingsHandler struct {
monitor *services.MonitorService
}
// NewSettingsHandler 创建配置处理器
func NewSettingsHandler() *SettingsHandler {
return &SettingsHandler{
monitor: services.GetMonitorService(),
}
}
// GetPublicMonitorSettings 公开：当前全局检测周期与可选值
func (h *SettingsHandler) GetPublicMonitorSettings(c *gin.Context) {
cfg := config.GetConfig()
c.JSON(http.StatusOK, models.APIResponse{
Code: 0,
Message: "success",
Data: gin.H{
"interval_minutes": int(cfg.Monitor.Interval.Minutes()),
"allowed_interval_minutes": config.AllowedMonitorIntervalMinutes,
},
})
}
// GetAdminConfig 管理端：监控相关配置（只读字段供面板展示）
func (h *SettingsHandler) GetAdminConfig(c *gin.Context) {
cfg := config.GetConfig()
c.JSON(http.StatusOK, models.APIResponse{
Code: 0,
Message: "success",
Data: gin.H{
"interval_minutes": int(cfg.Monitor.Interval.Minutes()),
"allowed_interval_minutes": config.AllowedMonitorIntervalMinutes,
"timeout_seconds": int(cfg.Monitor.Timeout.Seconds()),
"retry_count": cfg.Monitor.RetryCount,
"history_days": cfg.Monitor.HistoryDays,
},
})
}
type putAdminMonitorConfigRequest struct {
IntervalMinutes int `json:"interval_minutes" binding:"required"`
}
// PutAdminMonitorConfig 更新全局检测周期并持久化、应用新调度
func (h *SettingsHandler) PutAdminMonitorConfig(c *gin.Context) {
var req putAdminMonitorConfigRequest
if err := c.ShouldBindJSON(&req); err != nil {
c.JSON(http.StatusBadRequest, models.APIResponse{
Code: 400,
Message: "参数错误: " + err.Error(),
})
return
}
if err := storage.GetStorage().SetMonitorIntervalMinutes(req.IntervalMinutes); err != nil {
c.JSON(http.StatusBadRequest, models.APIResponse{
Code: 400,
Message: err.Error(),
})
return
}
h.monitor.Reschedule()
c.JSON(http.StatusOK, models.APIResponse{
Code: 0,
Message: "已更新检测周期",
Data: gin.H{
"interval_minutes": req.IntervalMinutes,
},
})
}

466
mengyaping-backend/handlers/website.go
View File

@@ -1,199 +1,267 @@
package handlers
import (
"net/http"
"github.com/gin-gonic/gin"
"mengyaping-backend/models"
"mengyaping-backend/services"
)
// WebsiteHandler 网站处理器
type WebsiteHandler struct {
websiteService *services.WebsiteService
monitorService *services.MonitorService
}
// NewWebsiteHandler 创建网站处理器
func NewWebsiteHandler() *WebsiteHandler {
return &WebsiteHandler{
websiteService: services.NewWebsiteService(),
monitorService: services.GetMonitorService(),
}
}
// GetWebsites 获取所有网站状态
func (h *WebsiteHandler) GetWebsites(c *gin.Context) {
statuses := h.monitorService.GetAllWebsiteStatuses()
c.JSON(http.StatusOK, models.APIResponse{
Code: 0,
Message: "success",
Data: statuses,
})
}
// GetWebsite 获取单个网站状态
func (h *WebsiteHandler) GetWebsite(c *gin.Context) {
id := c.Param("id")
status := h.monitorService.GetWebsiteStatus(id)
if status == nil {
c.JSON(http.StatusNotFound, models.APIResponse{
Code: 404,
Message: "网站不存在",
})
return
}
c.JSON(http.StatusOK, models.APIResponse{
Code: 0,
Message: "success",
Data: status,
})
}
// CreateWebsite 创建网站
func (h *WebsiteHandler) CreateWebsite(c *gin.Context) {
var req models.CreateWebsiteRequest
if err := c.ShouldBindJSON(&req); err != nil {
c.JSON(http.StatusBadRequest, models.APIResponse{
Code: 400,
Message: "参数错误: " + err.Error(),
})
return
}
website, err := h.websiteService.CreateWebsite(req)
if err != nil {
c.JSON(http.StatusInternalServerError, models.APIResponse{
Code: 500,
Message: "创建失败: " + err.Error(),
})
return
}
c.JSON(http.StatusOK, models.APIResponse{
Code: 0,
Message: "创建成功",
Data: website,
})
}
// UpdateWebsite 更新网站
func (h *WebsiteHandler) UpdateWebsite(c *gin.Context) {
id := c.Param("id")
var req models.UpdateWebsiteRequest
if err := c.ShouldBindJSON(&req); err != nil {
c.JSON(http.StatusBadRequest, models.APIResponse{
Code: 400,
Message: "参数错误: " + err.Error(),
})
return
}
website, err := h.websiteService.UpdateWebsite(id, req)
if err != nil {
c.JSON(http.StatusInternalServerError, models.APIResponse{
Code: 500,
Message: "更新失败: " + err.Error(),
})
return
}
if website == nil {
c.JSON(http.StatusNotFound, models.APIResponse{
Code: 404,
Message: "网站不存在",
})
return
}
c.JSON(http.StatusOK, models.APIResponse{
Code: 0,
Message: "更新成功",
Data: website,
})
}
// DeleteWebsite 删除网站
func (h *WebsiteHandler) DeleteWebsite(c *gin.Context) {
id := c.Param("id")
if err := h.websiteService.DeleteWebsite(id); err != nil {
c.JSON(http.StatusInternalServerError, models.APIResponse{
Code: 500,
Message: "删除失败: " + err.Error(),
})
return
}
c.JSON(http.StatusOK, models.APIResponse{
Code: 0,
Message: "删除成功",
})
}
// CheckWebsiteNow 立即检测网站
func (h *WebsiteHandler) CheckWebsiteNow(c *gin.Context) {
id := c.Param("id")
website := h.websiteService.GetWebsite(id)
if website == nil {
c.JSON(http.StatusNotFound, models.APIResponse{
Code: 404,
Message: "网站不存在",
})
return
}
h.monitorService.CheckWebsiteNow(id)
c.JSON(http.StatusOK, models.APIResponse{
Code: 0,
Message: "检测任务已提交",
})
}
// GetGroups 获取所有分组
func (h *WebsiteHandler) GetGroups(c *gin.Context) {
groups := h.websiteService.GetGroups()
c.JSON(http.StatusOK, models.APIResponse{
Code: 0,
Message: "success",
Data: groups,
})
}
// AddGroup 添加分组
func (h *WebsiteHandler) AddGroup(c *gin.Context) {
var req struct {
Name string `json:"name" binding:"required"`
}
if err := c.ShouldBindJSON(&req); err != nil {
c.JSON(http.StatusBadRequest, models.APIResponse{
Code: 400,
Message: "参数错误: " + err.Error(),
})
return
}
group, err := h.websiteService.AddGroup(req.Name)
if err != nil {
c.JSON(http.StatusInternalServerError, models.APIResponse{
Code: 500,
Message: "添加失败: " + err.Error(),
})
return
}
c.JSON(http.StatusOK, models.APIResponse{
Code: 0,
Message: "添加成功",
Data: group,
})
}
package handlers
import (
"net/http"
"github.com/gin-gonic/gin"
"mengyaping-backend/models"
"mengyaping-backend/services"
)
// WebsiteHandler 网站处理器
type WebsiteHandler struct {
websiteService *services.WebsiteService
monitorService *services.MonitorService
}
// NewWebsiteHandler 创建网站处理器
func NewWebsiteHandler() *WebsiteHandler {
return &WebsiteHandler{
websiteService: services.NewWebsiteService(),
monitorService: services.GetMonitorService(),
}
}
// GetWebsites 获取所有网站状态
func (h *WebsiteHandler) GetWebsites(c *gin.Context) {
statuses := h.monitorService.GetAllWebsiteStatuses()
c.JSON(http.StatusOK, models.APIResponse{
Code: 0,
Message: "success",
Data: statuses,
})
}
// GetWebsite 获取单个网站状态
func (h *WebsiteHandler) GetWebsite(c *gin.Context) {
id := c.Param("id")
status := h.monitorService.GetWebsiteStatus(id)
if status == nil {
c.JSON(http.StatusNotFound, models.APIResponse{
Code: 404,
Message: "网站不存在",
})
return
}
c.JSON(http.StatusOK, models.APIResponse{
Code: 0,
Message: "success",
Data: status,
})
}
// CreateWebsite 创建网站
func (h *WebsiteHandler) CreateWebsite(c *gin.Context) {
var req models.CreateWebsiteRequest
if err := c.ShouldBindJSON(&req); err != nil {
c.JSON(http.StatusBadRequest, models.APIResponse{
Code: 400,
Message: "参数错误: " + err.Error(),
})
return
}
website, err := h.websiteService.CreateWebsite(req)
if err != nil {
c.JSON(http.StatusInternalServerError, models.APIResponse{
Code: 500,
Message: "创建失败: " + err.Error(),
})
return
}
c.JSON(http.StatusOK, models.APIResponse{
Code: 0,
Message: "创建成功",
Data: website,
})
}
// UpdateWebsite 更新网站
func (h *WebsiteHandler) UpdateWebsite(c *gin.Context) {
id := c.Param("id")
var req models.UpdateWebsiteRequest
if err := c.ShouldBindJSON(&req); err != nil {
c.JSON(http.StatusBadRequest, models.APIResponse{
Code: 400,
Message: "参数错误: " + err.Error(),
})
return
}
website, err := h.websiteService.UpdateWebsite(id, req)
if err != nil {
c.JSON(http.StatusInternalServerError, models.APIResponse{
Code: 500,
Message: "更新失败: " + err.Error(),
})
return
}
if website == nil {
c.JSON(http.StatusNotFound, models.APIResponse{
Code: 404,
Message: "网站不存在",
})
return
}
c.JSON(http.StatusOK, models.APIResponse{
Code: 0,
Message: "更新成功",
Data: website,
})
}
// DeleteWebsite 删除网站
func (h *WebsiteHandler) DeleteWebsite(c *gin.Context) {
id := c.Param("id")
if err := h.websiteService.DeleteWebsite(id); err != nil {
c.JSON(http.StatusInternalServerError, models.APIResponse{
Code: 500,
Message: "删除失败: " + err.Error(),
})
return
}
c.JSON(http.StatusOK, models.APIResponse{
Code: 0,
Message: "删除成功",
})
}
// CheckWebsiteNow 立即检测网站
func (h *WebsiteHandler) CheckWebsiteNow(c *gin.Context) {
id := c.Param("id")
website := h.websiteService.GetWebsite(id)
if website == nil {
c.JSON(http.StatusNotFound, models.APIResponse{
Code: 404,
Message: "网站不存在",
})
return
}
h.monitorService.CheckWebsiteNow(id)
c.JSON(http.StatusOK, models.APIResponse{
Code: 0,
Message: "检测任务已提交",
})
}
// GetGroups 获取所有分组
func (h *WebsiteHandler) GetGroups(c *gin.Context) {
groups := h.websiteService.GetGroups()
c.JSON(http.StatusOK, models.APIResponse{
Code: 0,
Message: "success",
Data: groups,
})
}
// GetGroup 获取单个分组
func (h *WebsiteHandler) GetGroup(c *gin.Context) {
id := c.Param("id")
g := h.websiteService.GetGroup(id)
if g == nil {
c.JSON(http.StatusNotFound, models.APIResponse{
Code: 404,
Message: "分类不存在",
})
return
}
c.JSON(http.StatusOK, models.APIResponse{
Code: 0,
Message: "success",
Data: g,
})
}
// UpdateGroup 更新分组
func (h *WebsiteHandler) UpdateGroup(c *gin.Context) {
id := c.Param("id")
var req struct {
Name string `json:"name" binding:"required"`
}
if err := c.ShouldBindJSON(&req); err != nil {
c.JSON(http.StatusBadRequest, models.APIResponse{
Code: 400,
Message: "参数错误: " + err.Error(),
})
return
}
group, err := h.websiteService.UpdateGroup(id, req.Name)
if err != nil {
c.JSON(http.StatusBadRequest, models.APIResponse{
Code: 400,
Message: err.Error(),
})
return
}
c.JSON(http.StatusOK, models.APIResponse{
Code: 0,
Message: "更新成功",
Data: group,
})
}
// DeleteGroup 删除分组
func (h *WebsiteHandler) DeleteGroup(c *gin.Context) {
id := c.Param("id")
if err := h.websiteService.DeleteGroup(id); err != nil {
c.JSON(http.StatusBadRequest, models.APIResponse{
Code: 400,
Message: err.Error(),
})
return
}
c.JSON(http.StatusOK, models.APIResponse{
Code: 0,
Message: "删除成功",
})
}
// AddGroup 添加分组
func (h *WebsiteHandler) AddGroup(c *gin.Context) {
var req struct {
Name string `json:"name" binding:"required"`
}
if err := c.ShouldBindJSON(&req); err != nil {
c.JSON(http.StatusBadRequest, models.APIResponse{
Code: 400,
Message: "参数错误: " + err.Error(),
})
return
}
group, err := h.websiteService.AddGroup(req.Name)
if err != nil {
c.JSON(http.StatusInternalServerError, models.APIResponse{
Code: 500,
Message: "添加失败: " + err.Error(),
})
return
}
c.JSON(http.StatusOK, models.APIResponse{
Code: 0,
Message: "添加成功",
Data: group,
})
}

97
mengyaping-backend/main.go
View File

@@ -1,47 +1,50 @@
package main
import (
"fmt"
"log"
"os"
"os/signal"
"syscall"
"mengyaping-backend/config"
"mengyaping-backend/router"
"mengyaping-backend/services"
)
func main() {
// 获取配置
cfg := config.GetConfig()
// 确保数据目录存在
os.MkdirAll(cfg.DataPath, 0755)
// 启动监控服务
monitorService := services.GetMonitorService()
go monitorService.Start()
// 设置路由
r := router.SetupRouter()
// 优雅关闭
go func() {
sigCh := make(chan os.Signal, 1)
signal.Notify(sigCh, syscall.SIGINT, syscall.SIGTERM)
<-sigCh
log.Println("正在关闭服务...")
monitorService.Stop()
os.Exit(0)
}()
// 启动服务器
addr := fmt.Sprintf("%s:%s", cfg.Server.Host, cfg.Server.Port)
log.Printf("🌱 萌芽Ping 监控服务已启动，监听地址: %s\n", addr)
if err := r.Run(addr); err != nil {
log.Fatalf("服务器启动失败: %v", err)
}
}
package main
import (
"fmt"
"log"
"os"
"os/signal"
"syscall"
"mengyaping-backend/config"
"mengyaping-backend/router"
"mengyaping-backend/services"
"mengyaping-backend/storage"
)
func main() {
config.GetConfig()
// 连接 MySQL 并从 monitor_kv 加载应用配置（须在监听与监控协程使用配置之前）
storage.GetStorage()
cfg := config.GetConfig()
if err := os.MkdirAll(cfg.DataPath, 0755); err != nil {
log.Printf("创建数据目录 %s: %v", cfg.DataPath, err)
}
// 启动监控服务
monitorService := services.GetMonitorService()
go monitorService.Start()
// 设置路由
r := router.SetupRouter()
// 优雅关闭
go func() {
sigCh := make(chan os.Signal, 1)
signal.Notify(sigCh, syscall.SIGINT, syscall.SIGTERM)
<-sigCh
log.Println("正在关闭服务...")
monitorService.Stop()
os.Exit(0)
}()
// 启动服务器
addr := fmt.Sprintf("%s:%s", cfg.Server.Host, cfg.Server.Port)
log.Printf("🌱 萌芽Ping 监控服务已启动，监听地址: %s\n", addr)
if err := r.Run(addr); err != nil {
log.Fatalf("服务器启动失败: %v", err)
}
}

43
mengyaping-backend/middleware/admin.go Normal file
View File

@@ -0,0 +1,43 @@
package middleware
import (
"net/http"
"strings"
"github.com/gin-gonic/gin"
"mengyaping-backend/models"
"mengyaping-backend/storage"
)
// AdminAuth 校验管理员令牌：环境变量 ADMIN_TOKEN 优先，否则使用 MySQL monitor_kv 中的 admin_token（请求头 X-Admin-Token 或 Authorization: Bearer）
func AdminAuth() gin.HandlerFunc {
return func(c *gin.Context) {
expected := storage.GetStorage().EffectiveAdminToken()
if expected == "" {
c.AbortWithStatusJSON(http.StatusServiceUnavailable, models.APIResponse{
Code: 503,
Message: "未配置管理员令牌：请在数据库 monitor_kv 写入 admin_token，或设置环境变量 ADMIN_TOKEN",
})
return
}
got := strings.TrimSpace(c.GetHeader("X-Admin-Token"))
if got == "" {
auth := c.GetHeader("Authorization")
const prefix = "Bearer "
if len(auth) >= len(prefix) && strings.EqualFold(auth[:len(prefix)], prefix) {
got = strings.TrimSpace(auth[len(prefix):])
}
}
if got == "" || got != expected {
c.AbortWithStatusJSON(http.StatusUnauthorized, models.APIResponse{
Code: 401,
Message: "无效的管理员令牌",
})
return
}
c.Next()
}
}

230
mengyaping-backend/models/website.go
View File

@@ -1,113 +1,117 @@
package models
import (
"time"
)
// Website 网站信息
type Website struct {
ID string `json:"id"`
Name string `json:"name"` // 网站名称
Groups []string `json:"groups"` // 所属分组列表（支持多分组）
Group string `json:"group,omitempty"` // 已废弃，仅用于旧数据兼容
URLs []URLInfo `json:"urls"` // 网站访问地址列表
IPAddresses []string `json:"ip_addresses,omitempty"` // 域名解析的IP地址
Favicon string `json:"favicon"` // 网站图标URL
Title string `json:"title"` // 网站标题
CreatedAt time.Time `json:"created_at"` // 创建时间
UpdatedAt time.Time `json:"updated_at"` // 更新时间
}
// URLInfo 单个URL的信息
type URLInfo struct {
ID string `json:"id"`
URL string `json:"url"` // 访问地址
Remark string `json:"remark"` // 备注说明
}
// MonitorRecord 监控记录
type MonitorRecord struct {
WebsiteID string `json:"website_id"`
URLID string `json:"url_id"`
URL string `json:"url"`
StatusCode int `json:"status_code"` // HTTP状态码
Latency int64 `json:"latency"` // 延迟(毫秒)
IsUp bool `json:"is_up"` // 是否可访问
Error string `json:"error"` // 错误信息
CheckedAt time.Time `json:"checked_at"` // 检测时间
}
// WebsiteStatus 网站状态（用于前端展示）
type WebsiteStatus struct {
Website Website `json:"website"`
URLStatuses []URLStatus `json:"url_statuses"`
DailyHistory []DailyStats `json:"daily_history"` // 90天逐日统计
Uptime24h float64 `json:"uptime_24h"` // 24小时可用率
Uptime7d float64 `json:"uptime_7d"` // 7天可用率
Uptime90d float64 `json:"uptime_90d"` // 90天可用率
LastChecked time.Time `json:"last_checked"` // 最后检测时间
}
// URLStatus 单个URL的状态
type URLStatus struct {
URLInfo URLInfo `json:"url_info"`
CurrentState MonitorRecord `json:"current_state"` // 当前状态
History24h []MonitorRecord `json:"history_24h"` // 24小时历史
History7d []HourlyStats `json:"history_7d"` // 7天按小时统计
Uptime24h float64 `json:"uptime_24h"` // 24小时可用率
Uptime7d float64 `json:"uptime_7d"` // 7天可用率
AvgLatency int64 `json:"avg_latency"` // 平均延迟
}
// HourlyStats 每小时统计
type HourlyStats struct {
Hour time.Time `json:"hour"`
TotalCount int `json:"total_count"`
UpCount int `json:"up_count"`
AvgLatency int64 `json:"avg_latency"`
Uptime float64 `json:"uptime"`
}
// DailyStats 每日统计
type DailyStats struct {
Date time.Time `json:"date"`
TotalCount int `json:"total_count"`
UpCount int `json:"up_count"`
AvgLatency int64 `json:"avg_latency"`
Uptime float64 `json:"uptime"`
}
// Group 分组
type Group struct {
ID string `json:"id"`
Name string `json:"name"`
}
// DefaultGroups 默认分组
var DefaultGroups = []Group{
{ID: "normal", Name: "普通网站"},
{ID: "admin", Name: "管理员网站"},
}
// CreateWebsiteRequest 创建网站请求
type CreateWebsiteRequest struct {
Name string `json:"name" binding:"required"`
Groups []string `json:"groups" binding:"required,min=1"`
Group string `json:"group"`
URLs []string `json:"urls" binding:"required,min=1"`
}
// UpdateWebsiteRequest 更新网站请求
type UpdateWebsiteRequest struct {
Name string `json:"name"`
Groups []string `json:"groups"`
Group string `json:"group"`
URLs []string `json:"urls"`
}
// APIResponse API响应
type APIResponse struct {
Code int `json:"code"`
Message string `json:"message"`
Data interface{} `json:"data,omitempty"`
}
package models
import (
"time"
)
// Website 网站信息
type Website struct {
ID string `json:"id"`
Name string `json:"name"` // 网站名称
Groups []string `json:"groups"` // 所属分组列表（支持多分组）
Group string `json:"group,omitempty"` // 已废弃，仅用于旧数据兼容
URLs []URLInfo `json:"urls"` // 网站访问地址列表
IPAddresses []string `json:"ip_addresses,omitempty"` // 域名解析的IP地址
Favicon string `json:"favicon"` // 网站图标URL
Title string `json:"title"` // 网站标题
CreatedAt time.Time `json:"created_at"` // 创建时间
UpdatedAt time.Time `json:"updated_at"` // 更新时间
}
// URLInfo 单个URL的信息
type URLInfo struct {
ID string `json:"id"`
URL string `json:"url"` // 访问地址
Remark string `json:"remark"` // 备注说明
}
// MonitorRecord 监控记录
type MonitorRecord struct {
WebsiteID string `json:"website_id"`
URLID string `json:"url_id"`
URL string `json:"url"`
StatusCode int `json:"status_code"` // HTTP状态码
Latency int64 `json:"latency"` // 延迟(毫秒)
IsUp bool `json:"is_up"` // 是否可访问
Error string `json:"error"` // 错误信息
CheckedAt time.Time `json:"checked_at"` // 检测时间
}
// WebsiteStatus 网站状态（用于前端展示）
type WebsiteStatus struct {
Website Website `json:"website"`
IsIntranet bool `json:"is_intranet"` // 主 URL 为内网 IP：不解析公网 DNS、不展示解析 IP，用内网图标
URLStatuses []URLStatus `json:"url_statuses"`
DailyHistory []DailyStats `json:"daily_history"` // 90天逐日统计
Uptime24h float64 `json:"uptime_24h"` // 24小时可用率
Uptime7d float64 `json:"uptime_7d"` // 7天可用率
Uptime90d float64 `json:"uptime_90d"` // 90天可用率
LastChecked time.Time `json:"last_checked"` // 最后检测时间
}
// URLStatus 单个URL的状态
type URLStatus struct {
URLInfo URLInfo `json:"url_info"`
CurrentState MonitorRecord `json:"current_state"` // 当前状态
History24h []MonitorRecord `json:"history_24h"` // 24小时历史
History7d []HourlyStats `json:"history_7d"` // 7天按小时统计
Uptime24h float64 `json:"uptime_24h"` // 24小时可用率
Uptime7d float64 `json:"uptime_7d"` // 7天可用率
AvgLatency int64 `json:"avg_latency"` // 平均延迟
}
// HourlyStats 每小时统计
type HourlyStats struct {
Hour time.Time `json:"hour"`
TotalCount int `json:"total_count"`
UpCount int `json:"up_count"`
AvgLatency int64 `json:"avg_latency"`
Uptime float64 `json:"uptime"`
}
// DailyStats 每日统计
type DailyStats struct {
Date time.Time `json:"date"`
TotalCount int `json:"total_count"`
UpCount int `json:"up_count"`
AvgLatency int64 `json:"avg_latency"`
Uptime float64 `json:"uptime"`
}
// Group 分组
type Group struct {
ID string `json:"id"`
Name string `json:"name"`
}
// DefaultGroups 默认分组
var DefaultGroups = []Group{
{ID: "normal", Name: "普通网站"},
{ID: "admin", Name: "管理员网站"},
}
// DefaultIntranetFavicon 直填内网站点的列表图标（静态 SVG，不依赖公网 favicon 抓取）
const DefaultIntranetFavicon = "https://api.iconify.design/mdi/lan-connect.svg?color=%23059669"
// CreateWebsiteRequest 创建网站请求
type CreateWebsiteRequest struct {
Name string `json:"name" binding:"required"`
Groups []string `json:"groups" binding:"required,min=1"`
Group string `json:"group"`
URLs []string `json:"urls" binding:"required,min=1"`
}
// UpdateWebsiteRequest 更新网站请求
type UpdateWebsiteRequest struct {
Name string `json:"name"`
Groups []string `json:"groups"`
Group string `json:"group"`
URLs []string `json:"urls"`
}
// APIResponse API响应
type APIResponse struct {
Code int `json:"code"`
Message string `json:"message"`
Data interface{} `json:"data,omitempty"`
}

117
mengyaping-backend/router/router.go
View File

@@ -1,51 +1,66 @@
package router
import (
"github.com/gin-contrib/cors"
"github.com/gin-gonic/gin"
"mengyaping-backend/handlers"
)
// SetupRouter 设置路由
func SetupRouter() *gin.Engine {
r := gin.Default()
// CORS配置
r.Use(cors.New(cors.Config{
AllowOrigins: []string{"*"},
AllowMethods: []string{"GET", "POST", "PUT", "DELETE", "OPTIONS"},
AllowHeaders: []string{"Origin", "Content-Type", "Accept", "Authorization"},
ExposeHeaders: []string{"Content-Length"},
AllowCredentials: true,
}))
// 创建处理器
websiteHandler := handlers.NewWebsiteHandler()
// API路由组
api := r.Group("/api")
{
// 健康检查
api.GET("/health", func(c *gin.Context) {
c.JSON(200, gin.H{
"status": "ok",
"message": "服务运行正常",
})
})
// 网站相关
api.GET("/websites", websiteHandler.GetWebsites)
api.GET("/websites/:id", websiteHandler.GetWebsite)
api.POST("/websites", websiteHandler.CreateWebsite)
api.PUT("/websites/:id", websiteHandler.UpdateWebsite)
api.DELETE("/websites/:id", websiteHandler.DeleteWebsite)
api.POST("/websites/:id/check", websiteHandler.CheckWebsiteNow)
// 分组相关
api.GET("/groups", websiteHandler.GetGroups)
api.POST("/groups", websiteHandler.AddGroup)
}
return r
}
package router
import (
"github.com/gin-contrib/cors"
"github.com/gin-gonic/gin"
"mengyaping-backend/handlers"
"mengyaping-backend/middleware"
)
// SetupRouter 设置路由
func SetupRouter() *gin.Engine {
r := gin.Default()
// CORS配置
r.Use(cors.New(cors.Config{
AllowOrigins: []string{"*"},
AllowMethods: []string{"GET", "POST", "PUT", "DELETE", "OPTIONS"},
AllowHeaders: []string{"Origin", "Content-Type", "Accept", "Authorization", "X-Admin-Token"},
ExposeHeaders: []string{"Content-Length"},
AllowCredentials: true,
}))
// 创建处理器
websiteHandler := handlers.NewWebsiteHandler()
settingsHandler := handlers.NewSettingsHandler()
// API路由组
api := r.Group("/api")
{
// 健康检查
api.GET("/health", func(c *gin.Context) {
c.JSON(200, gin.H{
"status": "ok",
"message": "服务运行正常",
})
})
// 公开：监控调度信息（仅展示）
api.GET("/monitor/settings", settingsHandler.GetPublicMonitorSettings)
// 网站 / 分组 — 读操作公开
api.GET("/websites", websiteHandler.GetWebsites)
api.GET("/websites/:id", websiteHandler.GetWebsite)
api.GET("/groups", websiteHandler.GetGroups)
api.GET("/groups/:id", websiteHandler.GetGroup)
// 管理：写操作需 ADMIN_TOKEN
admin := api.Group("")
admin.Use(middleware.AdminAuth())
{
admin.POST("/websites", websiteHandler.CreateWebsite)
admin.PUT("/websites/:id", websiteHandler.UpdateWebsite)
admin.DELETE("/websites/:id", websiteHandler.DeleteWebsite)
admin.POST("/websites/:id/check", websiteHandler.CheckWebsiteNow)
admin.POST("/groups", websiteHandler.AddGroup)
admin.PUT("/groups/:id", websiteHandler.UpdateGroup)
admin.DELETE("/groups/:id", websiteHandler.DeleteGroup)
admin.GET("/admin/config", settingsHandler.GetAdminConfig)
admin.PUT("/admin/config", settingsHandler.PutAdminMonitorConfig)
}
}
return r
}

19
mengyaping-backend/schema/mysql.sql Normal file
View File

@@ -0,0 +1,19 @@
-- 萌芽 Ping — MySQL 8+ 表结构说明（应用启动时 GORM AutoMigrate 会自动建表；本文件便于 DBA 审阅或手工执行）
-- 字符集务必 utf8mb4
CREATE DATABASE IF NOT EXISTS mengyaping
DEFAULT CHARACTER SET utf8mb4
COLLATE utf8mb4_unicode_ci;
USE mengyaping;
-- monitor_groups 网站分类
-- monitor_websites 监控站点主档（ip_addresses 为 JSON 数组）
-- monitor_website_urls 每个站点下多监控 URL
-- monitor_website_groups 站点与分类多对多
-- monitor_checks HTTP 探活历史（按保留天数定期清理）
-- monitor_kv 键值配置：admin_token；cfg_server / cfg_monitor / cfg_data_path / cfg_database（JSON）
-- 与下列 GORM 模型一致：
-- MonitorGroup, MonitorWebsite, MonitorWebsiteURL, MonitorWebsiteGroup,
-- MonitorProbeLatest, MonitorProbeHour, MonitorProbeDay, MonitorKV

906
mengyaping-backend/services/monitor.go
View File

@@ -1,418 +1,488 @@
package services
import (
"log"
"sort"
"sync"
"time"
"mengyaping-backend/config"
"mengyaping-backend/models"
"mengyaping-backend/storage"
"mengyaping-backend/utils"
)
// MonitorService 监控服务
type MonitorService struct {
httpClient *utils.HTTPClient
storage *storage.Storage
stopCh chan struct{}
running bool
mu sync.Mutex
}
var (
monitorService *MonitorService
monitorOnce sync.Once
)
// GetMonitorService 获取监控服务单例
func GetMonitorService() *MonitorService {
monitorOnce.Do(func() {
cfg := config.GetConfig()
monitorService = &MonitorService{
httpClient: utils.NewHTTPClient(cfg.Monitor.Timeout),
storage: storage.GetStorage(),
stopCh: make(chan struct{}),
}
})
return monitorService
}
// Start 启动监控服务
func (s *MonitorService) Start() {
s.mu.Lock()
if s.running {
s.mu.Unlock()
return
}
s.running = true
s.mu.Unlock()
log.Println("监控服务已启动")
// 立即执行一次检测
go s.checkAll()
// 定时检测
cfg := config.GetConfig()
ticker := time.NewTicker(cfg.Monitor.Interval)
defer ticker.Stop()
for {
select {
case <-ticker.C:
go s.checkAll()
case <-s.stopCh:
log.Println("监控服务已停止")
return
}
}
}
// Stop 停止监控服务
func (s *MonitorService) Stop() {
s.mu.Lock()
defer s.mu.Unlock()
if s.running {
close(s.stopCh)
s.running = false
}
}
// checkAll 检查所有网站（错峰执行，避免并发暴涨）
func (s *MonitorService) checkAll() {
websites := s.storage.GetWebsites()
semaphore := make(chan struct{}, 3) // 最多 3 个并发检测
for i, website := range websites {
// 每个网站之间间隔 1 秒，把检测分散开
if i > 0 {
time.Sleep(1 * time.Second)
}
var wg sync.WaitGroup
for _, urlInfo := range website.URLs {
wg.Add(1)
go func(w models.Website, u models.URLInfo) {
defer wg.Done()
semaphore <- struct{}{}
defer func() { <-semaphore }()
s.checkURL(w, u)
}(website, urlInfo)
}
wg.Wait()
}
// 检测完毕后，逐个解析 DNS
s.resolveAllWebsiteIPs(websites)
// 保存记录
s.storage.SaveAll()
log.Printf("本轮检测完成，共 %d 个网站", len(websites))
}
// resolveAllWebsiteIPs 逐个解析所有网站域名 IP（每次都刷新）
func (s *MonitorService) resolveAllWebsiteIPs(websites []models.Website) {
for i, website := range websites {
if len(website.URLs) == 0 {
continue
}
if i > 0 {
time.Sleep(500 * time.Millisecond)
}
s.resolveWebsiteIP(website)
}
}
// resolveWebsiteIP 解析单个网站的域名 IP
func (s *MonitorService) resolveWebsiteIP(website models.Website) {
if len(website.URLs) == 0 {
return
}
ips, err := utils.ResolveDomainIPs(website.URLs[0].URL)
if err != nil {
log.Printf("DNS解析失败 [%s]: %v", website.Name, err)
return
}
if len(ips) == 0 {
return
}
w := s.storage.GetWebsite(website.ID)
if w == nil {
return
}
w.IPAddresses = ips
w.UpdatedAt = time.Now()
s.storage.UpdateWebsite(*w)
log.Printf("DNS解析 [%s] → %v", website.Name, ips)
}
// checkURL 检查单个URL（带重试）
func (s *MonitorService) checkURL(website models.Website, urlInfo models.URLInfo) {
cfg := config.GetConfig()
maxRetries := cfg.Monitor.RetryCount
var result utils.CheckResult
for attempt := 0; attempt <= maxRetries; attempt++ {
if attempt > 0 {
time.Sleep(time.Duration(attempt) * 2 * time.Second)
log.Printf("重试 [%s] %s - 第 %d 次重试", website.Name, urlInfo.URL, attempt)
}
result = s.httpClient.CheckWebsiteStatus(urlInfo.URL)
if result.Error == nil && utils.IsSuccessStatus(result.StatusCode) {
break
}
}
record := models.MonitorRecord{
WebsiteID: website.ID,
URLID: urlInfo.ID,
URL: urlInfo.URL,
StatusCode: result.StatusCode,
Latency: result.Latency.Milliseconds(),
IsUp: result.Error == nil && utils.IsSuccessStatus(result.StatusCode),
CheckedAt: time.Now(),
}
if result.Error != nil {
record.Error = result.Error.Error()
}
s.storage.AddRecord(record)
// 仅当网站无标题时才做完整检测来获取元数据
if record.IsUp && website.Title == "" {
fullResult := s.httpClient.CheckWebsite(urlInfo.URL)
if fullResult.Title != "" {
w := s.storage.GetWebsite(website.ID)
if w != nil {
w.Title = fullResult.Title
w.UpdatedAt = time.Now()
s.storage.UpdateWebsite(*w)
}
}
}
log.Printf("检测 [%s] %s - 状态码: %d, 延迟: %dms, 可用: %v",
website.Name, urlInfo.URL, result.StatusCode, result.Latency.Milliseconds(), record.IsUp)
}
// CheckWebsiteNow 立即检查指定网站（状态 + DNS，等待完成后保存）
func (s *MonitorService) CheckWebsiteNow(websiteID string) {
website := s.storage.GetWebsite(websiteID)
if website == nil {
return
}
// 逐个检测该网站的所有 URL
for _, urlInfo := range website.URLs {
s.checkURL(*website, urlInfo)
}
// 刷新 DNS
s.resolveWebsiteIP(*website)
s.storage.SaveAll()
}
// GetWebsiteStatus 获取网站状态
func (s *MonitorService) GetWebsiteStatus(websiteID string) *models.WebsiteStatus {
website := s.storage.GetWebsite(websiteID)
if website == nil {
return nil
}
status := &models.WebsiteStatus{
Website: *website,
URLStatuses: []models.URLStatus{},
}
now := time.Now()
since24h := now.Add(-24 * time.Hour)
since7d := now.Add(-7 * 24 * time.Hour)
since90d := now.Add(-90 * 24 * time.Hour)
var totalUptime24h, totalUptime7d float64
var urlCount int
var allRecords90d []models.MonitorRecord
for _, urlInfo := range website.URLs {
urlStatus := s.getURLStatus(website.ID, urlInfo, since24h, since7d)
status.URLStatuses = append(status.URLStatuses, urlStatus)
totalUptime24h += urlStatus.Uptime24h
totalUptime7d += urlStatus.Uptime7d
urlCount++
records90d := s.storage.GetRecords(website.ID, urlInfo.ID, since90d)
allRecords90d = append(allRecords90d, records90d...)
}
if urlCount > 0 {
status.Uptime24h = totalUptime24h / float64(urlCount)
status.Uptime7d = totalUptime7d / float64(urlCount)
}
// 90 天逐日统计
status.DailyHistory = s.aggregateByDay(allRecords90d)
if len(allRecords90d) > 0 {
upCount := 0
for _, r := range allRecords90d {
if r.IsUp {
upCount++
}
}
status.Uptime90d = float64(upCount) / float64(len(allRecords90d)) * 100
}
// 获取最后检测时间
for _, urlStatus := range status.URLStatuses {
if urlStatus.CurrentState.CheckedAt.After(status.LastChecked) {
status.LastChecked = urlStatus.CurrentState.CheckedAt
}
}
return status
}
// getURLStatus 获取URL状态
func (s *MonitorService) getURLStatus(websiteID string, urlInfo models.URLInfo, since24h, since7d time.Time) models.URLStatus {
urlStatus := models.URLStatus{
URLInfo: urlInfo,
}
// 获取最新记录
latest := s.storage.GetLatestRecord(websiteID, urlInfo.ID)
if latest != nil {
urlStatus.CurrentState = *latest
}
// 获取24小时记录
records24h := s.storage.GetRecords(websiteID, urlInfo.ID, since24h)
urlStatus.History24h = records24h
// 计算24小时可用率
if len(records24h) > 0 {
upCount := 0
var totalLatency int64
for _, r := range records24h {
if r.IsUp {
upCount++
}
totalLatency += r.Latency
}
urlStatus.Uptime24h = float64(upCount) / float64(len(records24h)) * 100
urlStatus.AvgLatency = totalLatency / int64(len(records24h))
}
// 获取7天记录并按小时统计
records7d := s.storage.GetRecords(websiteID, urlInfo.ID, since7d)
urlStatus.History7d = s.aggregateByHour(records7d)
// 计算7天可用率
if len(records7d) > 0 {
upCount := 0
for _, r := range records7d {
if r.IsUp {
upCount++
}
}
urlStatus.Uptime7d = float64(upCount) / float64(len(records7d)) * 100
}
return urlStatus
}
// aggregateByHour 按小时聚合记录
func (s *MonitorService) aggregateByHour(records []models.MonitorRecord) []models.HourlyStats {
hourlyMap := make(map[string]*models.HourlyStats)
for _, r := range records {
hourKey := r.CheckedAt.Truncate(time.Hour).Format(time.RFC3339)
if _, exists := hourlyMap[hourKey]; !exists {
hourlyMap[hourKey] = &models.HourlyStats{
Hour: r.CheckedAt.Truncate(time.Hour),
}
}
stats := hourlyMap[hourKey]
stats.TotalCount++
if r.IsUp {
stats.UpCount++
}
stats.AvgLatency += r.Latency
}
var result []models.HourlyStats
for _, stats := range hourlyMap {
if stats.TotalCount > 0 {
stats.AvgLatency /= int64(stats.TotalCount)
stats.Uptime = float64(stats.UpCount) / float64(stats.TotalCount) * 100
}
result = append(result, *stats)
}
return result
}
// aggregateByDay 按天聚合记录
func (s *MonitorService) aggregateByDay(records []models.MonitorRecord) []models.DailyStats {
dayMap := make(map[string]*models.DailyStats)
for _, r := range records {
dayTime := time.Date(r.CheckedAt.Year(), r.CheckedAt.Month(), r.CheckedAt.Day(), 0, 0, 0, 0, r.CheckedAt.Location())
dayKey := dayTime.Format("2006-01-02")
if _, exists := dayMap[dayKey]; !exists {
dayMap[dayKey] = &models.DailyStats{
Date: dayTime,
}
}
stats := dayMap[dayKey]
stats.TotalCount++
if r.IsUp {
stats.UpCount++
}
stats.AvgLatency += r.Latency
}
result := make([]models.DailyStats, 0, len(dayMap))
for _, stats := range dayMap {
if stats.TotalCount > 0 {
stats.AvgLatency /= int64(stats.TotalCount)
stats.Uptime = float64(stats.UpCount) / float64(stats.TotalCount) * 100
}
result = append(result, *stats)
}
sort.Slice(result, func(i, j int) bool {
return result[i].Date.Before(result[j].Date)
})
return result
}
// GetAllWebsiteStatuses 获取所有网站状态
func (s *MonitorService) GetAllWebsiteStatuses() []models.WebsiteStatus {
websites := s.storage.GetWebsites()
var statuses []models.WebsiteStatus
for _, website := range websites {
status := s.GetWebsiteStatus(website.ID)
if status != nil {
statuses = append(statuses, *status)
}
}
return statuses
}
package services
import (
"log"
"sync"
"time"
"mengyaping-backend/config"
"mengyaping-backend/models"
"mengyaping-backend/storage"
"mengyaping-backend/utils"
)
// MonitorService 监控服务
type MonitorService struct {
httpClient *utils.HTTPClient
storage *storage.Storage
stopCh chan struct{}
rescheduleCh chan struct{}
running bool
mu sync.Mutex
}
var (
monitorService *MonitorService
monitorOnce sync.Once
)
// GetMonitorService 获取监控服务单例
func GetMonitorService() *MonitorService {
monitorOnce.Do(func() {
st := storage.GetStorage()
cfg := config.GetConfig()
monitorService = &MonitorService{
httpClient: utils.NewHTTPClient(cfg.Monitor.Timeout),
storage: st,
stopCh: make(chan struct{}),
rescheduleCh: make(chan struct{}, 1),
}
})
return monitorService
}
// Start 启动监控服务
func (s *MonitorService) Start() {
s.mu.Lock()
if s.running {
s.mu.Unlock()
return
}
s.running = true
s.mu.Unlock()
log.Println("监控服务已启动")
go s.runLoop()
}
// Reschedule 在检测间隔配置变更后唤醒主循环以使用新周期（非阻塞）
func (s *MonitorService) Reschedule() {
select {
case s.rescheduleCh <- struct{}{}:
default:
}
}
func (s *MonitorService) runLoop() {
go s.checkAll()
d := config.GetConfig().Monitor.Interval
if d <= 0 {
d = 30 * time.Minute
}
timer := time.NewTimer(d)
defer timer.Stop()
for {
select {
case <-s.stopCh:
if !timer.Stop() {
select {
case <-timer.C:
default:
}
}
log.Println("监控服务已停止")
return
case <-s.rescheduleCh:
if !timer.Stop() {
select {
case <-timer.C:
default:
}
}
d = config.GetConfig().Monitor.Interval
if d <= 0 {
d = 30 * time.Minute
}
timer.Reset(d)
case <-timer.C:
go s.checkAll()
d = config.GetConfig().Monitor.Interval
if d <= 0 {
d = 30 * time.Minute
}
timer.Reset(d)
}
}
}
// Stop 停止监控服务
func (s *MonitorService) Stop() {
s.mu.Lock()
defer s.mu.Unlock()
if s.running {
close(s.stopCh)
s.running = false
}
}
// checkAll 检查所有网站（错峰执行，避免并发暴涨）
func (s *MonitorService) checkAll() {
websites := s.storage.GetWebsites()
semaphore := make(chan struct{}, 3) // 最多 3 个并发检测
for i, website := range websites {
// 每个网站之间间隔 1 秒，把检测分散开
if i > 0 {
time.Sleep(1 * time.Second)
}
var wg sync.WaitGroup
for _, urlInfo := range website.URLs {
wg.Add(1)
go func(w models.Website, u models.URLInfo) {
defer wg.Done()
semaphore <- struct{}{}
defer func() { <-semaphore }()
s.checkURL(w, u)
}(website, urlInfo)
}
wg.Wait()
}
// 检测完毕后，逐个解析 DNS
s.resolveAllWebsiteIPs(websites)
// 保存记录
s.storage.SaveAll()
log.Printf("本轮检测完成，共 %d 个网站", len(websites))
}
// resolveAllWebsiteIPs 逐个解析所有网站域名 IP（每次都刷新）
func (s *MonitorService) resolveAllWebsiteIPs(websites []models.Website) {
for i, website := range websites {
if len(website.URLs) == 0 {
continue
}
if i > 0 {
time.Sleep(500 * time.Millisecond)
}
s.resolveWebsiteIP(website)
}
}
// resolveWebsiteIP 解析单个网站的域名 IP
func (s *MonitorService) resolveWebsiteIP(website models.Website) {
if len(website.URLs) == 0 {
return
}
if utils.IsIntranetURL(website.URLs[0].URL) {
w := s.storage.GetWebsite(website.ID)
if w != nil && len(w.IPAddresses) > 0 {
w.IPAddresses = nil
w.UpdatedAt = time.Now()
s.storage.UpdateWebsite(*w)
}
return
}
ips, err := utils.ResolveDomainIPs(website.URLs[0].URL)
if err != nil {
log.Printf("DNS解析失败 [%s]: %v", website.Name, err)
return
}
if len(ips) == 0 {
return
}
w := s.storage.GetWebsite(website.ID)
if w == nil {
return
}
w.IPAddresses = ips
w.UpdatedAt = time.Now()
s.storage.UpdateWebsite(*w)
log.Printf("DNS解析 [%s] → %v", website.Name, ips)
}
// checkURL 检查单个URL（带重试）
func (s *MonitorService) checkURL(website models.Website, urlInfo models.URLInfo) {
cfg := config.GetConfig()
maxRetries := cfg.Monitor.RetryCount
var result utils.CheckResult
for attempt := 0; attempt <= maxRetries; attempt++ {
if attempt > 0 {
time.Sleep(time.Duration(attempt) * 2 * time.Second)
log.Printf("重试 [%s] %s - 第 %d 次重试", website.Name, urlInfo.URL, attempt)
}
result = s.httpClient.CheckWebsiteStatus(urlInfo.URL)
if result.Error == nil && utils.IsSuccessStatus(result.StatusCode) {
break
}
}
record := models.MonitorRecord{
WebsiteID: website.ID,
URLID: urlInfo.ID,
URL: urlInfo.URL,
StatusCode: result.StatusCode,
Latency: result.Latency.Milliseconds(),
IsUp: result.Error == nil && utils.IsSuccessStatus(result.StatusCode),
CheckedAt: time.Now(),
}
if result.Error != nil {
record.Error = result.Error.Error()
}
s.storage.AddRecord(record)
// 仅当网站无标题时才做完整检测来获取元数据
if record.IsUp && website.Title == "" {
fullResult := s.httpClient.CheckWebsite(urlInfo.URL)
if fullResult.Title != "" {
w := s.storage.GetWebsite(website.ID)
if w != nil {
w.Title = fullResult.Title
w.UpdatedAt = time.Now()
s.storage.UpdateWebsite(*w)
}
}
}
log.Printf("检测 [%s] %s - 状态码: %d, 延迟: %dms, 可用: %v",
website.Name, urlInfo.URL, result.StatusCode, result.Latency.Milliseconds(), record.IsUp)
}
// CheckWebsiteNow 立即检查指定网站（状态 + DNS，等待完成后保存）
func (s *MonitorService) CheckWebsiteNow(websiteID string) {
website := s.storage.GetWebsite(websiteID)
if website == nil {
return
}
// 逐个检测该网站的所有 URL
for _, urlInfo := range website.URLs {
s.checkURL(*website, urlInfo)
}
// 刷新 DNS
s.resolveWebsiteIP(*website)
s.storage.SaveAll()
}
// GetWebsiteStatus 获取网站状态
func (s *MonitorService) GetWebsiteStatus(websiteID string) *models.WebsiteStatus {
website := s.storage.GetWebsite(websiteID)
if website == nil {
return nil
}
isIntranet := len(website.URLs) > 0 && utils.IsIntranetURL(website.URLs[0].URL)
status := &models.WebsiteStatus{
Website: *website,
IsIntranet: isIntranet,
URLStatuses: []models.URLStatus{},
}
now := time.Now()
since24h := now.Add(-24 * time.Hour)
since7d := now.Add(-7 * 24 * time.Hour)
since90d := now.Add(-90 * 24 * time.Hour)
var totalUptime24h, totalUptime7d float64
var urlCount int
for _, urlInfo := range website.URLs {
urlStatus := s.getURLStatus(website.ID, urlInfo, since24h, since7d)
status.URLStatuses = append(status.URLStatuses, urlStatus)
totalUptime24h += urlStatus.Uptime24h
totalUptime7d += urlStatus.Uptime7d
urlCount++
}
if urlCount > 0 {
status.Uptime24h = totalUptime24h / float64(urlCount)
status.Uptime7d = totalUptime7d / float64(urlCount)
}
status.DailyHistory = s.storage.GetWebsiteDailyAggregates(website.ID, since90d)
if pt, ut := s.storage.GetWebsiteDayProbeTotals(website.ID, since90d); pt > 0 {
status.Uptime90d = float64(ut) / float64(pt) * 100
}
// 获取最后检测时间
for _, urlStatus := range status.URLStatuses {
if urlStatus.CurrentState.CheckedAt.After(status.LastChecked) {
status.LastChecked = urlStatus.CurrentState.CheckedAt
}
}
return status
}
// getURLStatus 获取URL状态：每个 URL 仅 1 次读小时表 + 1 次读 latest（在内存拆 24h/7d）
func (s *MonitorService) getURLStatus(websiteID string, urlInfo models.URLInfo, since24h, since7d time.Time) models.URLStatus {
var latest *models.MonitorRecord
if rec := s.storage.GetLatestRecord(websiteID, urlInfo.ID); rec != nil {
latest = rec
}
hRows := s.storage.GetProbeHourRowsForURL(websiteID, urlInfo.ID, since7d)
return s.buildURLStatusFromHours(websiteID, urlInfo, since24h, since7d, latest, hRows)
}
func hourlyStatFromProbeRow(h storage.MonitorProbeHour) models.HourlyStats {
st := models.HourlyStats{
Hour: h.HourAt,
TotalCount: h.ProbeCount,
UpCount: h.UpCount,
}
if h.ProbeCount > 0 {
st.AvgLatency = h.LatencySum / int64(h.ProbeCount)
st.Uptime = float64(h.UpCount) / float64(h.ProbeCount) * 100
}
return st
}
func hourWindowsFromRows(rows []storage.MonitorProbeHour, since24h, since7d time.Time) (
stats24h []models.HourlyStats,
stats7d []models.HourlyStats,
t24, u24, l24, t7, u7 int64,
) {
for _, h := range rows {
if !h.HourAt.Before(since7d) {
t7 += int64(h.ProbeCount)
u7 += int64(h.UpCount)
stats7d = append(stats7d, hourlyStatFromProbeRow(h))
}
if !h.HourAt.Before(since24h) {
t24 += int64(h.ProbeCount)
u24 += int64(h.UpCount)
l24 += h.LatencySum
stats24h = append(stats24h, hourlyStatFromProbeRow(h))
}
}
return stats24h, stats7d, t24, u24, l24, t7, u7
}
func (s *MonitorService) buildURLStatusFromHours(
websiteID string,
urlInfo models.URLInfo,
since24h, since7d time.Time,
latest *models.MonitorRecord,
hRows []storage.MonitorProbeHour,
) models.URLStatus {
urlStatus := models.URLStatus{URLInfo: urlInfo}
if latest != nil {
urlStatus.CurrentState = *latest
}
s24, s7, t24, u24, l24, t7, u7 := hourWindowsFromRows(hRows, since24h, since7d)
urlStatus.History24h = hourlyStatsToMonitorRecords(websiteID, urlInfo.ID, s24)
if t24 > 0 {
urlStatus.Uptime24h = float64(u24) / float64(t24) * 100
urlStatus.AvgLatency = l24 / t24
}
urlStatus.History7d = s7
if t7 > 0 {
urlStatus.Uptime7d = float64(u7) / float64(t7) * 100
}
return urlStatus
}
func hourlyStatsToMonitorRecords(websiteID, urlID string, stats []models.HourlyStats) []models.MonitorRecord {
out := make([]models.MonitorRecord, 0, len(stats))
for _, h := range stats {
isUp := h.TotalCount > 0 && h.UpCount*2 >= h.TotalCount
out = append(out, models.MonitorRecord{
WebsiteID: websiteID,
URLID: urlID,
Latency: h.AvgLatency,
IsUp: isUp,
CheckedAt: h.Hour,
})
}
return out
}
// GetAllWebsiteStatuses 获取所有网站状态（批量查 probe 表，避免每个站点/URL 多次 SQL）
func (s *MonitorService) GetAllWebsiteStatuses() []models.WebsiteStatus {
websites := s.storage.GetWebsites()
if len(websites) == 0 {
return nil
}
now := time.Now()
since24h := now.Add(-24 * time.Hour)
since7d := now.Add(-7 * 24 * time.Hour)
since90d := now.Add(-90 * 24 * time.Hour)
since90dDay := time.Date(since90d.Year(), since90d.Month(), since90d.Day(), 0, 0, 0, 0, since90d.Location())
latestMap := s.storage.GetProbeLatestKeyMap()
hourMap := s.storage.GroupProbeHoursSince(since7d)
dailyBySite, uptime90dBySite := s.storage.LoadAllWebsiteDayRollups(since90dDay)
statuses := make([]models.WebsiteStatus, 0, len(websites))
for _, w := range websites {
daily := dailyBySite[w.ID]
u90 := uptime90dBySite[w.ID]
st := s.buildWebsiteStatusBulk(w, since24h, since7d, latestMap, hourMap, daily, u90)
if st != nil {
statuses = append(statuses, *st)
}
}
return statuses
}
func (s *MonitorService) buildWebsiteStatusBulk(
w models.Website,
since24h, since7d time.Time,
latestMap map[string]models.MonitorRecord,
hourMap map[string]map[string][]storage.MonitorProbeHour,
daily []models.DailyStats,
uptime90d float64,
) *models.WebsiteStatus {
isIntranet := len(w.URLs) > 0 && utils.IsIntranetURL(w.URLs[0].URL)
status := &models.WebsiteStatus{
Website: w,
IsIntranet: isIntranet,
URLStatuses: []models.URLStatus{},
}
siteHours := hourMap[w.ID]
if siteHours == nil {
siteHours = map[string][]storage.MonitorProbeHour{}
}
var totalUptime24h, totalUptime7d float64
urlCount := 0
for _, urlInfo := range w.URLs {
key := w.ID + "\x00" + urlInfo.ID
var latest *models.MonitorRecord
if rec, ok := latestMap[key]; ok {
r := rec
latest = &r
}
hRows := siteHours[urlInfo.ID]
urlSt := s.buildURLStatusFromHours(w.ID, urlInfo, since24h, since7d, latest, hRows)
status.URLStatuses = append(status.URLStatuses, urlSt)
totalUptime24h += urlSt.Uptime24h
totalUptime7d += urlSt.Uptime7d
urlCount++
}
if urlCount > 0 {
status.Uptime24h = totalUptime24h / float64(urlCount)
status.Uptime7d = totalUptime7d / float64(urlCount)
}
if daily != nil {
status.DailyHistory = daily
} else {
status.DailyHistory = []models.DailyStats{}
}
status.Uptime90d = uptime90d
for _, urlSt := range status.URLStatuses {
if urlSt.CurrentState.CheckedAt.After(status.LastChecked) {
status.LastChecked = urlSt.CurrentState.CheckedAt
}
}
return status
}

319
mengyaping-backend/services/website.go
View File

@@ -1,142 +1,177 @@
package services
import (
"time"
"mengyaping-backend/models"
"mengyaping-backend/storage"
"mengyaping-backend/utils"
)
// WebsiteService 网站服务
type WebsiteService struct {
storage *storage.Storage
}
// NewWebsiteService 创建网站服务
func NewWebsiteService() *WebsiteService {
return &WebsiteService{
storage: storage.GetStorage(),
}
}
// CreateWebsite 创建网站
func (s *WebsiteService) CreateWebsite(req models.CreateWebsiteRequest) (*models.Website, error) {
groups := req.Groups
if len(groups) == 0 && req.Group != "" {
groups = []string{req.Group}
}
website := models.Website{
ID: utils.GenerateID(),
Name: req.Name,
Groups: groups,
URLs: make([]models.URLInfo, 0),
CreatedAt: time.Now(),
UpdatedAt: time.Now(),
}
for _, url := range req.URLs {
urlInfo := models.URLInfo{
ID: utils.GenerateShortID(),
URL: url,
}
website.URLs = append(website.URLs, urlInfo)
}
// 创建前先解析域名 IP
if len(req.URLs) > 0 {
if ips, err := utils.ResolveDomainIPs(req.URLs[0]); err == nil {
website.IPAddresses = ips
}
}
if err := s.storage.AddWebsite(website); err != nil {
return nil, err
}
// 立即检测该网站
go GetMonitorService().CheckWebsiteNow(website.ID)
return &website, nil
}
// GetWebsite 获取网站
func (s *WebsiteService) GetWebsite(id string) *models.Website {
return s.storage.GetWebsite(id)
}
// GetAllWebsites 获取所有网站
func (s *WebsiteService) GetAllWebsites() []models.Website {
return s.storage.GetWebsites()
}
// UpdateWebsite 更新网站
func (s *WebsiteService) UpdateWebsite(id string, req models.UpdateWebsiteRequest) (*models.Website, error) {
website := s.storage.GetWebsite(id)
if website == nil {
return nil, nil
}
if req.Name != "" {
website.Name = req.Name
}
if len(req.Groups) > 0 {
website.Groups = req.Groups
} else if req.Group != "" {
website.Groups = []string{req.Group}
}
if len(req.URLs) > 0 {
// 保留已有URL的ID，添加新URL
existingURLs := make(map[string]models.URLInfo)
for _, u := range website.URLs {
existingURLs[u.URL] = u
}
newURLs := make([]models.URLInfo, 0)
for _, url := range req.URLs {
if existing, ok := existingURLs[url]; ok {
newURLs = append(newURLs, existing)
} else {
newURLs = append(newURLs, models.URLInfo{
ID: utils.GenerateShortID(),
URL: url,
})
}
}
website.URLs = newURLs
website.IPAddresses = nil // URL 变更后清空 IP，等下次检测重新解析
}
website.UpdatedAt = time.Now()
if err := s.storage.UpdateWebsite(*website); err != nil {
return nil, err
}
return website, nil
}
// DeleteWebsite 删除网站
func (s *WebsiteService) DeleteWebsite(id string) error {
return s.storage.DeleteWebsite(id)
}
// GetGroups 获取所有分组
func (s *WebsiteService) GetGroups() []models.Group {
return s.storage.GetGroups()
}
// AddGroup 添加分组
func (s *WebsiteService) AddGroup(name string) (*models.Group, error) {
group := models.Group{
ID: utils.GenerateShortID(),
Name: name,
}
if err := s.storage.AddGroup(group); err != nil {
return nil, err
}
return &group, nil
}
package services
import (
"fmt"
"strings"
"time"
"mengyaping-backend/models"
"mengyaping-backend/storage"
"mengyaping-backend/utils"
)
// WebsiteService 网站服务
type WebsiteService struct {
storage *storage.Storage
}
// NewWebsiteService 创建网站服务
func NewWebsiteService() *WebsiteService {
return &WebsiteService{
storage: storage.GetStorage(),
}
}
// CreateWebsite 创建网站
func (s *WebsiteService) CreateWebsite(req models.CreateWebsiteRequest) (*models.Website, error) {
groups := req.Groups
if len(groups) == 0 && req.Group != "" {
groups = []string{req.Group}
}
website := models.Website{
ID: utils.GenerateID(),
Name: req.Name,
Groups: groups,
URLs: make([]models.URLInfo, 0),
CreatedAt: time.Now(),
UpdatedAt: time.Now(),
}
for _, url := range req.URLs {
urlInfo := models.URLInfo{
ID: utils.GenerateShortID(),
URL: url,
}
website.URLs = append(website.URLs, urlInfo)
}
if len(req.URLs) > 0 {
if utils.IsIntranetURL(req.URLs[0]) {
website.Favicon = models.DefaultIntranetFavicon
website.IPAddresses = nil
} else {
if ips, err := utils.ResolveDomainIPs(req.URLs[0]); err == nil {
website.IPAddresses = ips
}
}
}
if err := s.storage.AddWebsite(website); err != nil {
return nil, err
}
// 立即检测该网站
go GetMonitorService().CheckWebsiteNow(website.ID)
return &website, nil
}
// GetWebsite 获取网站
func (s *WebsiteService) GetWebsite(id string) *models.Website {
return s.storage.GetWebsite(id)
}
// GetAllWebsites 获取所有网站
func (s *WebsiteService) GetAllWebsites() []models.Website {
return s.storage.GetWebsites()
}
// UpdateWebsite 更新网站
func (s *WebsiteService) UpdateWebsite(id string, req models.UpdateWebsiteRequest) (*models.Website, error) {
website := s.storage.GetWebsite(id)
if website == nil {
return nil, nil
}
if req.Name != "" {
website.Name = req.Name
}
if len(req.Groups) > 0 {
website.Groups = req.Groups
} else if req.Group != "" {
website.Groups = []string{req.Group}
}
if len(req.URLs) > 0 {
// 保留已有URL的ID，添加新URL
existingURLs := make(map[string]models.URLInfo)
for _, u := range website.URLs {
existingURLs[u.URL] = u
}
newURLs := make([]models.URLInfo, 0)
for _, url := range req.URLs {
if existing, ok := existingURLs[url]; ok {
newURLs = append(newURLs, existing)
} else {
newURLs = append(newURLs, models.URLInfo{
ID: utils.GenerateShortID(),
URL: url,
})
}
}
website.URLs = newURLs
website.IPAddresses = nil // URL 变更后清空 IP，等下次检测重新解析
if len(req.URLs) > 0 && utils.IsIntranetURL(req.URLs[0]) {
website.Favicon = models.DefaultIntranetFavicon
website.IPAddresses = nil
}
}
website.UpdatedAt = time.Now()
if err := s.storage.UpdateWebsite(*website); err != nil {
return nil, err
}
return website, nil
}
// DeleteWebsite 删除网站
func (s *WebsiteService) DeleteWebsite(id string) error {
return s.storage.DeleteWebsite(id)
}
// GetGroups 获取所有分组
func (s *WebsiteService) GetGroups() []models.Group {
return s.storage.GetGroups()
}
// AddGroup 添加分组
func (s *WebsiteService) AddGroup(name string) (*models.Group, error) {
name = strings.TrimSpace(name)
if name == "" {
return nil, fmt.Errorf("分类名称不能为空")
}
group := models.Group{
ID: utils.GenerateShortID(),
Name: name,
}
if err := s.storage.AddGroup(group); err != nil {
return nil, err
}
return &group, nil
}
// GetGroup 获取单个分组
func (s *WebsiteService) GetGroup(id string) *models.Group {
return s.storage.GetGroupByID(id)
}
// UpdateGroup 更新分类名称
func (s *WebsiteService) UpdateGroup(id string, name string) (*models.Group, error) {
if err := s.storage.UpdateGroup(id, name); err != nil {
return nil, err
}
g := s.storage.GetGroupByID(id)
return g, nil
}
// DeleteGroup 删除分类
func (s *WebsiteService) DeleteGroup(id string) error {
return s.storage.DeleteGroup(id)
}

161
mengyaping-backend/storage/app_config.go Normal file
View File

@@ -0,0 +1,161 @@
package storage
import (
"encoding/json"
"fmt"
"log"
"time"
"mengyaping-backend/config"
)
const (
kvKeyServer = "cfg_server"
kvKeyMonitor = "cfg_monitor"
kvKeyDataPath = "cfg_data_path"
kvKeyDatabase = "cfg_database"
)
type monitorKVPayload struct {
IntervalMinutes int `json:"interval_minutes"`
TimeoutSeconds int `json:"timeout_seconds"`
RetryCount int `json:"retry_count"`
HistoryDays int `json:"history_days"`
}
func (s *Storage) getKVRaw(key string) string {
var row MonitorKV
s.db.Where("cfg_key = ?", key).Limit(1).Find(&row)
if row.CfgKey == "" {
return ""
}
return row.CfgValue
}
func (s *Storage) setKVRaw(key, val string) error {
var row MonitorKV
s.db.Where("cfg_key = ?", key).Limit(1).Find(&row)
if row.CfgKey == "" {
return s.db.Create(&MonitorKV{CfgKey: key, CfgValue: val}).Error
}
row.CfgValue = val
return s.db.Save(&row).Error
}
// loadAndSyncAppConfig 从 monitor_kv 覆盖内存配置，再写回全量（补全缺省键、统一格式）
func (s *Storage) loadAndSyncAppConfig() {
cfg := config.GetConfig()
if v := s.getKVRaw(kvKeyServer); v != "" {
var sc config.ServerConfig
if err := json.Unmarshal([]byte(v), &sc); err != nil {
log.Printf("解析 %s: %v", kvKeyServer, err)
} else {
if sc.Port != "" {
cfg.Server.Port = sc.Port
}
if sc.Host != "" {
cfg.Server.Host = sc.Host
}
}
}
if v := s.getKVRaw(kvKeyMonitor); v != "" {
var m monitorKVPayload
if err := json.Unmarshal([]byte(v), &m); err != nil {
log.Printf("解析 %s: %v", kvKeyMonitor, err)
} else {
if m.IntervalMinutes > 0 {
snapped := config.SnapMonitorIntervalMinutes(m.IntervalMinutes)
cfg.Monitor.Interval = time.Duration(snapped) * time.Minute
}
if m.TimeoutSeconds > 0 {
cfg.Monitor.Timeout = time.Duration(m.TimeoutSeconds) * time.Second
}
if m.RetryCount > 0 {
cfg.Monitor.RetryCount = m.RetryCount
}
if m.HistoryDays > 0 {
cfg.Monitor.HistoryDays = m.HistoryDays
}
}
}
if v := s.getKVRaw(kvKeyDataPath); v != "" {
cfg.DataPath = v
}
if v := s.getKVRaw(kvKeyDatabase); v != "" {
var dc config.DatabaseConfig
if err := json.Unmarshal([]byte(v), &dc); err != nil {
log.Printf("解析 %s: %v", kvKeyDatabase, err)
} else {
if dc.Host != "" {
cfg.Database.Host = dc.Host
}
if dc.Port != "" {
cfg.Database.Port = dc.Port
}
if dc.User != "" {
cfg.Database.User = dc.User
}
if dc.Password != "" {
cfg.Database.Password = dc.Password
}
if dc.Database != "" {
cfg.Database.Database = dc.Database
}
}
}
if err := s.PersistAppConfig(); err != nil {
log.Printf("同步应用配置到 monitor_kv: %v", err)
}
}
// PersistAppConfig 将当前内存中的 server/monitor/data_path/database 写入 monitor_kv
func (s *Storage) PersistAppConfig() error {
cfg := config.GetConfig()
b, err := json.Marshal(cfg.Server)
if err != nil {
return err
}
if err := s.setKVRaw(kvKeyServer, string(b)); err != nil {
return err
}
m := monitorKVPayload{
IntervalMinutes: config.SnapMonitorIntervalMinutes(int(cfg.Monitor.Interval / time.Minute)),
TimeoutSeconds: int(cfg.Monitor.Timeout.Seconds()),
RetryCount: cfg.Monitor.RetryCount,
HistoryDays: cfg.Monitor.HistoryDays,
}
b, err = json.Marshal(m)
if err != nil {
return err
}
if err := s.setKVRaw(kvKeyMonitor, string(b)); err != nil {
return err
}
if err := s.setKVRaw(kvKeyDataPath, cfg.DataPath); err != nil {
return err
}
b, err = json.Marshal(cfg.Database)
if err != nil {
return err
}
return s.setKVRaw(kvKeyDatabase, string(b))
}
// SetMonitorIntervalMinutes 更新检测周期并写入 monitor_kv
func (s *Storage) SetMonitorIntervalMinutes(minutes int) error {
if !config.IsAllowedMonitorInterval(minutes) {
return fmt.Errorf("interval_minutes 必须是预设值之一: %v", config.AllowedMonitorIntervalMinutes)
}
cfg := config.GetConfig()
cfg.Monitor.Interval = time.Duration(minutes) * time.Minute
return s.PersistAppConfig()
}

14
mengyaping-backend/storage/db_kv.go Normal file
View File

@@ -0,0 +1,14 @@
package storage
import "time"
// MonitorKV 键值配置（管理员令牌等），列名避开 MySQL 保留字 key/value
type MonitorKV struct {
CfgKey string `gorm:"primaryKey;size:128;column:cfg_key"`
CfgValue string `gorm:"type:text;column:cfg_value"`
UpdatedAt time.Time `gorm:"autoUpdateTime"`
}
func (MonitorKV) TableName() string { return "monitor_kv" }
const kvKeyAdminToken = "admin_token"

93
mengyaping-backend/storage/db_models.go Normal file
View File

@@ -0,0 +1,93 @@
package storage
import (
"time"
"gorm.io/datatypes"
)
// MonitorGroup 网站分类（避免使用 MySQL 保留字 group）
type MonitorGroup struct {
ID string `gorm:"primaryKey;size:64"`
Name string `gorm:"size:255;not null"`
SortOrder int `gorm:"default:0;index"`
CreatedAt time.Time `gorm:"autoCreateTime"`
UpdatedAt time.Time `gorm:"autoUpdateTime"`
}
func (MonitorGroup) TableName() string { return "monitor_groups" }
// MonitorWebsite 监控站点主表
type MonitorWebsite struct {
ID string `gorm:"primaryKey;size:128"`
Name string `gorm:"size:255;not null;index"`
LegacyGroup string `gorm:"size:64;column:legacy_group"` // 旧版单分组，仅兼容
Favicon string `gorm:"type:text"`
Title string `gorm:"size:512"`
IPAddresses datatypes.JSON `gorm:"type:json"` // []string
CreatedAt time.Time `gorm:"autoCreateTime"`
UpdatedAt time.Time `gorm:"autoUpdateTime"`
URLs []MonitorWebsiteURL `gorm:"foreignKey:WebsiteID;constraint:OnUpdate:CASCADE,OnDelete:CASCADE"`
GroupLinks []MonitorWebsiteGroup `gorm:"foreignKey:WebsiteID;constraint:OnUpdate:CASCADE,OnDelete:CASCADE"`
}
func (MonitorWebsite) TableName() string { return "monitor_websites" }
// MonitorWebsiteURL 站点监控 URL（一对多）
type MonitorWebsiteURL struct {
ID uint64 `gorm:"primaryKey;autoIncrement"`
WebsiteID string `gorm:"size:128;not null;index:idx_url_site,priority:1"`
URLID string `gorm:"size:64;not null;index:idx_url_site,priority:2"`
URL string `gorm:"type:text;not null"`
Remark string `gorm:"size:512"`
SortOrder int `gorm:"default:0"`
}
func (MonitorWebsiteURL) TableName() string { return "monitor_website_urls" }
// MonitorWebsiteGroup 站点与分类多对多
type MonitorWebsiteGroup struct {
WebsiteID string `gorm:"primaryKey;size:128"`
GroupID string `gorm:"primaryKey;size:64"`
}
func (MonitorWebsiteGroup) TableName() string { return "monitor_website_groups" }
// MonitorProbeLatest 每个 URL 最新一次探测结果（不逐条存历史）
type MonitorProbeLatest struct {
WebsiteID string `gorm:"primaryKey;size:128"`
URLID string `gorm:"primaryKey;size:64"`
URL string `gorm:"type:text"`
StatusCode int `gorm:"column:status_code"`
LatencyMs int64 `gorm:"column:latency_ms"`
IsUp bool `gorm:"column:is_up"`
ErrorText string `gorm:"type:text;column:error_text"`
CheckedAt time.Time `gorm:"index"`
}
func (MonitorProbeLatest) TableName() string { return "monitor_probe_latest" }
// MonitorProbeHour 按小时汇总（用于 24h / 7d 统计与图表），行数 ≈ URL 数 × 小时数
type MonitorProbeHour struct {
WebsiteID string `gorm:"primaryKey;size:128"`
URLID string `gorm:"primaryKey;size:64"`
HourAt time.Time `gorm:"primaryKey;type:datetime"` // 整点
ProbeCount int `gorm:"default:0"`
UpCount int `gorm:"default:0"`
LatencySum int64 `gorm:"default:0"` // 总延迟 ms，均值为 sum/count
}
func (MonitorProbeHour) TableName() string { return "monitor_probe_hour" }
// MonitorProbeDay 按自然日汇总（用于 90 天柱状图），行数 ≈ URL 数 × 天数
type MonitorProbeDay struct {
WebsiteID string `gorm:"primaryKey;size:128"`
URLID string `gorm:"primaryKey;size:64"`
StatDate time.Time `gorm:"primaryKey;type:date"`
ProbeCount int `gorm:"default:0"`
UpCount int `gorm:"default:0"`
LatencySum int64 `gorm:"default:0"`
}
func (MonitorProbeDay) TableName() string { return "monitor_probe_day" }

62
mengyaping-backend/storage/kv.go Normal file
View File

@@ -0,0 +1,62 @@
package storage
import (
"errors"
"log"
"os"
"strings"
)
var errEmptyAdminToken = errors.New("admin_token 不能为空")
// EffectiveAdminToken 管理员令牌：环境变量 ADMIN_TOKEN 优先，否则读 MySQL monitor_kv
func (s *Storage) EffectiveAdminToken() string {
if v := strings.TrimSpace(os.Getenv("ADMIN_TOKEN")); v != "" {
return v
}
return strings.TrimSpace(s.adminTokenFromDB())
}
func (s *Storage) adminTokenFromDB() string {
var row MonitorKV
if err := s.db.Where("cfg_key = ?", kvKeyAdminToken).Limit(1).Find(&row).Error; err != nil {
return ""
}
if row.CfgKey == "" {
return ""
}
return row.CfgValue
}
// SetAdminToken 更新数据库中的管理员令牌（需已能通过 AdminAuth）
func (s *Storage) SetAdminToken(token string) error {
token = strings.TrimSpace(token)
if token == "" {
return errEmptyAdminToken
}
var row MonitorKV
s.db.Where("cfg_key = ?", kvKeyAdminToken).Limit(1).Find(&row)
if row.CfgKey == "" {
return s.db.Create(&MonitorKV{CfgKey: kvKeyAdminToken, CfgValue: token}).Error
}
row.CfgValue = token
return s.db.Save(&row).Error
}
func (s *Storage) seedAdminTokenKV() {
var n int64
s.db.Model(&MonitorKV{}).Where("cfg_key = ?", kvKeyAdminToken).Count(&n)
if n > 0 {
return
}
val := strings.TrimSpace(os.Getenv("ADMIN_TOKEN"))
if val == "" {
log.Println("提示: 数据库 monitor_kv 中尚无 admin_token。可设置环境变量 ADMIN_TOKEN 后重启以自动写入，或对 monitor_kv 执行 INSERT。")
return
}
if err := s.db.Create(&MonitorKV{CfgKey: kvKeyAdminToken, CfgValue: val}).Error; err != nil {
log.Printf("写入初始 admin_token 失败: %v", err)
return
}
log.Println("已从环境变量 ADMIN_TOKEN 写入数据库 monitor_kv（后续可去掉该环境变量，改用库中令牌）。")
}

295
mengyaping-backend/storage/probe.go Normal file
View File

@@ -0,0 +1,295 @@
package storage
import (
"log"
"time"
"gorm.io/gorm"
"mengyaping-backend/config"
"mengyaping-backend/models"
)
func latestToRecord(p *MonitorProbeLatest) models.MonitorRecord {
return models.MonitorRecord{
WebsiteID: p.WebsiteID,
URLID: p.URLID,
URL: p.URL,
StatusCode: p.StatusCode,
Latency: p.LatencyMs,
IsUp: p.IsUp,
Error: p.ErrorText,
CheckedAt: p.CheckedAt,
}
}
// AddRecord 写入最新探测 + 按小时/按天汇总（不插逐条历史）
func (s *Storage) AddRecord(record models.MonitorRecord) error {
hourAt := record.CheckedAt.Truncate(time.Hour)
statDate := time.Date(record.CheckedAt.Year(), record.CheckedAt.Month(), record.CheckedAt.Day(),
0, 0, 0, 0, record.CheckedAt.Location())
upDelta := 0
if record.IsUp {
upDelta = 1
}
return s.db.Transaction(func(tx *gorm.DB) error {
lp := MonitorProbeLatest{
WebsiteID: record.WebsiteID,
URLID: record.URLID,
URL: record.URL,
StatusCode: record.StatusCode,
LatencyMs: record.Latency,
IsUp: record.IsUp,
ErrorText: record.Error,
CheckedAt: record.CheckedAt,
}
if err := tx.Save(&lp).Error; err != nil {
return err
}
if err := tx.Exec(`
INSERT INTO monitor_probe_hour (website_id, url_id, hour_at, probe_count, up_count, latency_sum)
VALUES (?, ?, ?, 1, ?, ?)
ON DUPLICATE KEY UPDATE
probe_count = probe_count + 1,
up_count = up_count + VALUES(up_count),
latency_sum = latency_sum + VALUES(latency_sum)
`, record.WebsiteID, record.URLID, hourAt, upDelta, record.Latency).Error; err != nil {
return err
}
return tx.Exec(`
INSERT INTO monitor_probe_day (website_id, url_id, stat_date, probe_count, up_count, latency_sum)
VALUES (?, ?, ?, 1, ?, ?)
ON DUPLICATE KEY UPDATE
probe_count = probe_count + 1,
up_count = up_count + VALUES(up_count),
latency_sum = latency_sum + VALUES(latency_sum)
`, record.WebsiteID, record.URLID, statDate.Format("2006-01-02"), upDelta, record.Latency).Error
})
}
// GetLatestRecord 最新一条（无记录时返回 nil；用 Find 而非 First，避免 GORM 将「未找到」打成 record not found 日志）
func (s *Storage) GetLatestRecord(websiteID, urlID string) *models.MonitorRecord {
var p MonitorProbeLatest
if err := s.db.Where("website_id = ? AND url_id = ?", websiteID, urlID).Limit(1).Find(&p).Error; err != nil {
return nil
}
if p.WebsiteID == "" {
return nil
}
m := latestToRecord(&p)
return &m
}
// GetRecords 兼容旧接口：按小时聚合展开为「代表点」（每探测窗口 1 条），仅用于仍依赖 slice 的逻辑；新逻辑请用汇总 API
func (s *Storage) GetRecords(websiteID, urlID string, since time.Time) []models.MonitorRecord {
rows := s.getProbeHourRows(websiteID, urlID, since)
var out []models.MonitorRecord
for _, h := range rows {
if h.ProbeCount <= 0 {
continue
}
avgLat := h.LatencySum / int64(h.ProbeCount)
isUp := h.UpCount*2 >= h.ProbeCount
out = append(out, models.MonitorRecord{
WebsiteID: websiteID,
URLID: urlID,
StatusCode: 0,
Latency: avgLat,
IsUp: isUp,
CheckedAt: h.HourAt,
})
}
return out
}
func (s *Storage) getProbeHourRows(websiteID, urlID string, since time.Time) []MonitorProbeHour {
var rows []MonitorProbeHour
s.db.Where("website_id = ? AND url_id = ? AND hour_at >= ?", websiteID, urlID, since).
Order("hour_at ASC").Find(&rows)
return rows
}
// GetProbeHourRowsForURL 某 URL 自 since 起的小时汇总行（升序）
func (s *Storage) GetProbeHourRowsForURL(websiteID, urlID string, since time.Time) []MonitorProbeHour {
return s.getProbeHourRows(websiteID, urlID, since)
}
// GetProbeLatestKeyMap 全表 latest（每 URL 一行），key = website_id + "\x00" + url_id
func (s *Storage) GetProbeLatestKeyMap() map[string]models.MonitorRecord {
var rows []MonitorProbeLatest
if err := s.db.Find(&rows).Error; err != nil {
log.Printf("GetProbeLatestKeyMap: %v", err)
return map[string]models.MonitorRecord{}
}
m := make(map[string]models.MonitorRecord, len(rows))
for i := range rows {
k := rows[i].WebsiteID + "\x00" + rows[i].URLID
m[k] = latestToRecord(&rows[i])
}
return m
}
// GroupProbeHoursSince 近窗口内全部小时汇总，按站点、URL 分组（列表接口一次查出）
func (s *Storage) GroupProbeHoursSince(since time.Time) map[string]map[string][]MonitorProbeHour {
var rows []MonitorProbeHour
if err := s.db.Where("hour_at >= ?", since).Order("website_id, url_id, hour_at").Find(&rows).Error; err != nil {
log.Printf("GroupProbeHoursSince: %v", err)
return map[string]map[string][]MonitorProbeHour{}
}
out := make(map[string]map[string][]MonitorProbeHour)
for i := range rows {
h := rows[i]
if out[h.WebsiteID] == nil {
out[h.WebsiteID] = make(map[string][]MonitorProbeHour)
}
out[h.WebsiteID][h.URLID] = append(out[h.WebsiteID][h.URLID], h)
}
return out
}
// LoadAllWebsiteDayRollups 自 since 日起各站每日汇总 + 90d 整体可用率（单条 SQL 聚合）
func (s *Storage) LoadAllWebsiteDayRollups(since time.Time) (map[string][]models.DailyStats, map[string]float64) {
sinceDay := time.Date(since.Year(), since.Month(), since.Day(), 0, 0, 0, 0, since.Location())
sinceStr := sinceDay.Format("2006-01-02")
type aggRow struct {
Wid string `gorm:"column:wid"`
D time.Time `gorm:"column:d"`
Pc int64 `gorm:"column:pc"`
Uc int64 `gorm:"column:uc"`
Ls int64 `gorm:"column:ls"`
}
var agg []aggRow
if err := s.db.Raw(`
SELECT website_id AS wid, stat_date AS d, SUM(probe_count) AS pc, SUM(up_count) AS uc, SUM(latency_sum) AS ls
FROM monitor_probe_day
WHERE stat_date >= ?
GROUP BY website_id, stat_date
ORDER BY website_id, stat_date
`, sinceStr).Scan(&agg).Error; err != nil {
log.Printf("LoadAllWebsiteDayRollups: %v", err)
return map[string][]models.DailyStats{}, map[string]float64{}
}
daily := make(map[string][]models.DailyStats)
totP := make(map[string]int64)
totU := make(map[string]int64)
for _, r := range agg {
st := models.DailyStats{
Date: r.D,
TotalCount: int(r.Pc),
UpCount: int(r.Uc),
}
if r.Pc > 0 {
st.AvgLatency = r.Ls / r.Pc
st.Uptime = float64(r.Uc) / float64(r.Pc) * 100
}
daily[r.Wid] = append(daily[r.Wid], st)
totP[r.Wid] += r.Pc
totU[r.Wid] += r.Uc
}
uptime := make(map[string]float64)
for wid, p := range totP {
if p > 0 {
uptime[wid] = float64(totU[wid]) / float64(p) * 100
}
}
return daily, uptime
}
// GetProbeHourTotals 某 URL 在时间窗口内汇总（来自小时表）
func (s *Storage) GetProbeHourTotals(websiteID, urlID string, since time.Time) (probeTotal int64, upTotal int64, latencySum int64) {
type row struct {
P int64
U int64
L int64
}
var r row
s.db.Model(&MonitorProbeHour{}).
Select("COALESCE(SUM(probe_count),0), COALESCE(SUM(up_count),0), COALESCE(SUM(latency_sum),0)").
Where("website_id = ? AND url_id = ? AND hour_at >= ?", websiteID, urlID, since).
Scan(&r)
return r.P, r.U, r.L
}
// GetHourlyStatsForURL 7 天折线用（已聚合）
func (s *Storage) GetHourlyStatsForURL(websiteID, urlID string, since time.Time) []models.HourlyStats {
rows := s.getProbeHourRows(websiteID, urlID, since)
out := make([]models.HourlyStats, 0, len(rows))
for _, h := range rows {
st := models.HourlyStats{
Hour: h.HourAt,
TotalCount: h.ProbeCount,
UpCount: h.UpCount,
}
if h.ProbeCount > 0 {
st.AvgLatency = h.LatencySum / int64(h.ProbeCount)
st.Uptime = float64(h.UpCount) / float64(h.ProbeCount) * 100
}
out = append(out, st)
}
return out
}
// GetWebsiteDailyAggregates 站点维度按日合并（多 URL 汇总到同一天）
func (s *Storage) GetWebsiteDailyAggregates(websiteID string, since time.Time) []models.DailyStats {
type aggRow struct {
D time.Time `gorm:"column:d"`
Pc int64 `gorm:"column:pc"`
Uc int64 `gorm:"column:uc"`
Ls int64 `gorm:"column:ls"`
}
var rows []aggRow
sinceDay := time.Date(since.Year(), since.Month(), since.Day(), 0, 0, 0, 0, since.Location())
s.db.Raw(`
SELECT stat_date AS d, SUM(probe_count) AS pc, SUM(up_count) AS uc, SUM(latency_sum) AS ls
FROM monitor_probe_day
WHERE website_id = ? AND stat_date >= ?
GROUP BY stat_date
ORDER BY stat_date ASC
`, websiteID, sinceDay.Format("2006-01-02")).Scan(&rows)
out := make([]models.DailyStats, 0, len(rows))
for _, r := range rows {
st := models.DailyStats{
Date: r.D,
TotalCount: int(r.Pc),
UpCount: int(r.Uc),
}
if r.Pc > 0 {
st.AvgLatency = r.Ls / r.Pc
st.Uptime = float64(r.Uc) / float64(r.Pc) * 100
}
out = append(out, st)
}
return out
}
// GetWebsiteDayProbeTotals 整站在日期范围内探测次数汇总（用于 90 天可用率）
func (s *Storage) GetWebsiteDayProbeTotals(websiteID string, since time.Time) (probeTotal int64, upTotal int64) {
sinceDay := time.Date(since.Year(), since.Month(), since.Day(), 0, 0, 0, 0, since.Location())
type row struct {
P int64
U int64
}
var r row
s.db.Model(&MonitorProbeDay{}).
Select("COALESCE(SUM(probe_count),0), COALESCE(SUM(up_count),0)").
Where("website_id = ? AND stat_date >= ?", websiteID, sinceDay.Format("2006-01-02")).
Scan(&r)
return r.P, r.U
}
func (s *Storage) purgeProbeRollups() {
cfg := config.GetConfig()
now := time.Now()
dayCutoff := now.AddDate(0, 0, -cfg.Monitor.HistoryDays).Truncate(24 * time.Hour)
if err := s.db.Where("stat_date < ?", dayCutoff.Format("2006-01-02")).Delete(&MonitorProbeDay{}).Error; err != nil {
log.Printf("清理 monitor_probe_day: %v", err)
}
// 小时图保留约 10 天（覆盖 7 天曲线 + 余量）
hourCutoff := now.Add(-10 * 24 * time.Hour).Truncate(time.Hour)
if err := s.db.Where("hour_at < ?", hourCutoff).Delete(&MonitorProbeHour{}).Error; err != nil {
log.Printf("清理 monitor_probe_hour: %v", err)
}
}

667
mengyaping-backend/storage/storage.go
View File

@@ -1,302 +1,365 @@
package storage
import (
"encoding/json"
"os"
"path/filepath"
"sync"
"time"
"mengyaping-backend/config"
"mengyaping-backend/models"
)
// Storage 数据存储
type Storage struct {
dataPath string
mu sync.RWMutex
websites []models.Website
records map[string][]models.MonitorRecord // key: websiteID_urlID
groups []models.Group
}
var (
store *Storage
once sync.Once
)
// GetStorage 获取存储单例
func GetStorage() *Storage {
once.Do(func() {
cfg := config.GetConfig()
store = &Storage{
dataPath: cfg.DataPath,
websites: []models.Website{},
records: make(map[string][]models.MonitorRecord),
groups: models.DefaultGroups,
}
store.ensureDataDir()
store.load()
})
return store
}
// ensureDataDir 确保数据目录存在
func (s *Storage) ensureDataDir() {
os.MkdirAll(s.dataPath, 0755)
}
// load 加载数据
func (s *Storage) load() {
s.loadWebsites()
s.loadRecords()
s.loadGroups()
}
// loadWebsites 加载网站数据
func (s *Storage) loadWebsites() {
filePath := filepath.Join(s.dataPath, "websites.json")
data, err := os.ReadFile(filePath)
if err != nil {
return
}
json.Unmarshal(data, &s.websites)
s.migrateWebsiteGroups()
}
// migrateWebsiteGroups 将旧的单分组字段迁移到多分组数组
func (s *Storage) migrateWebsiteGroups() {
migrated := false
for i := range s.websites {
w := &s.websites[i]
if len(w.Groups) == 0 && w.Group != "" {
w.Groups = []string{w.Group}
w.Group = ""
migrated = true
}
}
if migrated {
s.saveWebsites()
}
}
// loadRecords 加载监控记录
func (s *Storage) loadRecords() {
filePath := filepath.Join(s.dataPath, "records.json")
data, err := os.ReadFile(filePath)
if err != nil {
return
}
json.Unmarshal(data, &s.records)
// 清理过期记录
s.cleanOldRecords()
}
// loadGroups 加载分组
func (s *Storage) loadGroups() {
filePath := filepath.Join(s.dataPath, "groups.json")
data, err := os.ReadFile(filePath)
if err != nil {
// 使用默认分组
s.groups = models.DefaultGroups
s.saveGroups()
return
}
json.Unmarshal(data, &s.groups)
}
// saveWebsites 保存网站数据
func (s *Storage) saveWebsites() error {
filePath := filepath.Join(s.dataPath, "websites.json")
data, err := json.MarshalIndent(s.websites, "", " ")
if err != nil {
return err
}
return os.WriteFile(filePath, data, 0644)
}
// saveRecords 保存监控记录
func (s *Storage) saveRecords() error {
filePath := filepath.Join(s.dataPath, "records.json")
data, err := json.MarshalIndent(s.records, "", " ")
if err != nil {
return err
}
return os.WriteFile(filePath, data, 0644)
}
// saveGroups 保存分组
func (s *Storage) saveGroups() error {
filePath := filepath.Join(s.dataPath, "groups.json")
data, err := json.MarshalIndent(s.groups, "", " ")
if err != nil {
return err
}
return os.WriteFile(filePath, data, 0644)
}
// cleanOldRecords 清理过期记录
func (s *Storage) cleanOldRecords() {
cfg := config.GetConfig()
cutoff := time.Now().AddDate(0, 0, -cfg.Monitor.HistoryDays)
for key, records := range s.records {
var newRecords []models.MonitorRecord
for _, r := range records {
if r.CheckedAt.After(cutoff) {
newRecords = append(newRecords, r)
}
}
s.records[key] = newRecords
}
}
// GetWebsites 获取所有网站
func (s *Storage) GetWebsites() []models.Website {
s.mu.RLock()
defer s.mu.RUnlock()
result := make([]models.Website, len(s.websites))
copy(result, s.websites)
return result
}
// GetWebsite 获取单个网站
func (s *Storage) GetWebsite(id string) *models.Website {
s.mu.RLock()
defer s.mu.RUnlock()
for _, w := range s.websites {
if w.ID == id {
website := w
return &website
}
}
return nil
}
// AddWebsite 添加网站
func (s *Storage) AddWebsite(website models.Website) error {
s.mu.Lock()
defer s.mu.Unlock()
s.websites = append(s.websites, website)
return s.saveWebsites()
}
// UpdateWebsite 更新网站
func (s *Storage) UpdateWebsite(website models.Website) error {
s.mu.Lock()
defer s.mu.Unlock()
for i, w := range s.websites {
if w.ID == website.ID {
s.websites[i] = website
return s.saveWebsites()
}
}
return nil
}
// DeleteWebsite 删除网站
func (s *Storage) DeleteWebsite(id string) error {
s.mu.Lock()
defer s.mu.Unlock()
for i, w := range s.websites {
if w.ID == id {
s.websites = append(s.websites[:i], s.websites[i+1:]...)
// 删除相关记录
for key := range s.records {
if len(key) > len(id) && key[:len(id)] == id {
delete(s.records, key)
}
}
s.saveRecords()
return s.saveWebsites()
}
}
return nil
}
// AddRecord 添加监控记录
func (s *Storage) AddRecord(record models.MonitorRecord) error {
s.mu.Lock()
defer s.mu.Unlock()
key := record.WebsiteID + "_" + record.URLID
s.records[key] = append(s.records[key], record)
// 每100条记录保存一次
if len(s.records[key])%100 == 0 {
return s.saveRecords()
}
return nil
}
// GetRecords 获取监控记录
func (s *Storage) GetRecords(websiteID, urlID string, since time.Time) []models.MonitorRecord {
s.mu.RLock()
defer s.mu.RUnlock()
key := websiteID + "_" + urlID
records := s.records[key]
var result []models.MonitorRecord
for _, r := range records {
if r.CheckedAt.After(since) {
result = append(result, r)
}
}
return result
}
// GetLatestRecord 获取最新记录
func (s *Storage) GetLatestRecord(websiteID, urlID string) *models.MonitorRecord {
s.mu.RLock()
defer s.mu.RUnlock()
key := websiteID + "_" + urlID
records := s.records[key]
if len(records) == 0 {
return nil
}
latest := records[len(records)-1]
return &latest
}
// GetGroups 获取所有分组
func (s *Storage) GetGroups() []models.Group {
s.mu.RLock()
defer s.mu.RUnlock()
result := make([]models.Group, len(s.groups))
copy(result, s.groups)
return result
}
// AddGroup 添加分组
func (s *Storage) AddGroup(group models.Group) error {
s.mu.Lock()
defer s.mu.Unlock()
s.groups = append(s.groups, group)
return s.saveGroups()
}
// SaveAll 保存所有数据
func (s *Storage) SaveAll() error {
s.mu.Lock()
defer s.mu.Unlock()
if err := s.saveWebsites(); err != nil {
return err
}
if err := s.saveRecords(); err != nil {
return err
}
return s.saveGroups()
}
package storage
import (
"encoding/json"
"fmt"
"log"
"os"
"strings"
"sync"
"time"
"gorm.io/datatypes"
"gorm.io/driver/mysql"
"gorm.io/gorm"
"gorm.io/gorm/logger"
"mengyaping-backend/config"
"mengyaping-backend/models"
)
// Storage 基于 MySQL 的持久化（站点 / 分类 / 检测记录）
type Storage struct {
db *gorm.DB
}
var (
store *Storage
once sync.Once
)
// GetStorage 初始化数据库连接并迁移表结构
func GetStorage() *Storage {
once.Do(func() {
cfg := config.GetConfig()
dsn := cfg.DatabaseDSN()
gormLog := logger.Default.LogMode(logger.Warn)
if os.Getenv("DB_DEBUG") == "1" {
gormLog = logger.Default.LogMode(logger.Info)
}
db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{
Logger: gormLog,
})
if err != nil {
log.Fatalf("MySQL 连接失败: %v（请检查 DB_* / DB_DSN 环境变量）", err)
}
sqlDB, err := db.DB()
if err != nil {
log.Fatalf("MySQL sqlDB: %v", err)
}
sqlDB.SetMaxIdleConns(8)
sqlDB.SetMaxOpenConns(40)
sqlDB.SetConnMaxLifetime(time.Hour)
store = &Storage{db: db}
if err := store.migrate(); err != nil {
log.Fatalf("数据库迁移失败: %v", err)
}
store.seedAdminTokenKV()
store.loadAndSyncAppConfig()
store.seedDefaultGroups()
log.Println("MySQL 存储已就绪: " + cfg.Database.Database + "@" + cfg.Database.Host)
})
return store
}
func (s *Storage) migrate() error {
err := s.db.AutoMigrate(
&MonitorGroup{},
&MonitorWebsite{},
&MonitorWebsiteURL{},
&MonitorWebsiteGroup{},
&MonitorProbeLatest{},
&MonitorProbeHour{},
&MonitorProbeDay{},
&MonitorKV{},
)
if err != nil {
return err
}
// 旧版逐条 monitor_checks 表体积极大，已弃用
if s.db.Migrator().HasTable("monitor_checks") {
if err := s.db.Migrator().DropTable("monitor_checks"); err != nil {
log.Printf("删除旧表 monitor_checks: %v（可手工 DROP）", err)
} else {
log.Println("已删除旧表 monitor_checks")
}
}
return nil
}
func (s *Storage) seedDefaultGroups() {
var n int64
s.db.Model(&MonitorGroup{}).Count(&n)
if n > 0 {
return
}
order := 0
for _, g := range models.DefaultGroups {
order++
s.db.Create(&MonitorGroup{
ID: g.ID,
Name: g.Name,
SortOrder: order,
})
}
log.Println("已写入默认分类 monitor_groups")
}
func ipsToJSON(ips []string) []byte {
if ips == nil {
ips = []string{}
}
b, err := json.Marshal(ips)
if err != nil {
return []byte("[]")
}
return b
}
func jsonToIPs(raw []byte) []string {
if len(raw) == 0 {
return nil
}
var ips []string
if err := json.Unmarshal(raw, &ips); err != nil {
return nil
}
return ips
}
func rowToWebsite(w *MonitorWebsite) models.Website {
groups := make([]string, 0, len(w.GroupLinks))
for _, l := range w.GroupLinks {
groups = append(groups, l.GroupID)
}
if len(groups) == 0 && w.LegacyGroup != "" {
groups = []string{w.LegacyGroup}
}
urls := make([]models.URLInfo, 0, len(w.URLs))
for _, u := range w.URLs {
urls = append(urls, models.URLInfo{
ID: u.URLID,
URL: u.URL,
Remark: u.Remark,
})
}
return models.Website{
ID: w.ID,
Name: w.Name,
Groups: groups,
Group: "",
URLs: urls,
IPAddresses: jsonToIPs(w.IPAddresses),
Favicon: w.Favicon,
Title: w.Title,
CreatedAt: w.CreatedAt,
UpdatedAt: w.UpdatedAt,
}
}
func websiteToRow(w *models.Website) *MonitorWebsite {
return &MonitorWebsite{
ID: w.ID,
Name: w.Name,
LegacyGroup: "",
Favicon: w.Favicon,
Title: w.Title,
IPAddresses: datatypes.JSON(ipsToJSON(w.IPAddresses)),
CreatedAt: w.CreatedAt,
UpdatedAt: w.UpdatedAt,
}
}
func (s *Storage) listWebsiteModels() ([]models.Website, error) {
var rows []MonitorWebsite
if err := s.db.Preload("URLs", func(db *gorm.DB) *gorm.DB {
return db.Order("sort_order ASC, id ASC")
}).Preload("GroupLinks").Order("created_at ASC").Find(&rows).Error; err != nil {
return nil, err
}
out := make([]models.Website, len(rows))
for i := range rows {
out[i] = rowToWebsite(&rows[i])
}
return out, nil
}
// GetWebsites 获取所有网站
func (s *Storage) GetWebsites() []models.Website {
list, err := s.listWebsiteModels()
if err != nil {
log.Printf("GetWebsites: %v", err)
return nil
}
return list
}
// GetWebsite 获取单个网站
func (s *Storage) GetWebsite(id string) *models.Website {
var w MonitorWebsite
if err := s.db.Preload("URLs", func(db *gorm.DB) *gorm.DB {
return db.Order("sort_order ASC, id ASC")
}).Preload("GroupLinks").First(&w, "id = ?", id).Error; err != nil {
return nil
}
m := rowToWebsite(&w)
return &m
}
func (s *Storage) persistWebsiteFull(w models.Website) error {
return s.db.Transaction(func(tx *gorm.DB) error {
row := websiteToRow(&w)
if err := tx.Save(row).Error; err != nil {
return err
}
if err := tx.Where("website_id = ?", w.ID).Delete(&MonitorWebsiteURL{}).Error; err != nil {
return err
}
if err := tx.Where("website_id = ?", w.ID).Delete(&MonitorWebsiteGroup{}).Error; err != nil {
return err
}
for i, u := range w.URLs {
if err := tx.Create(&MonitorWebsiteURL{
WebsiteID: w.ID,
URLID: u.ID,
URL: u.URL,
Remark: u.Remark,
SortOrder: i,
}).Error; err != nil {
return err
}
}
for _, gid := range w.Groups {
if err := tx.Create(&MonitorWebsiteGroup{WebsiteID: w.ID, GroupID: gid}).Error; err != nil {
return err
}
}
return nil
})
}
// AddWebsite 添加网站
func (s *Storage) AddWebsite(website models.Website) error {
return s.persistWebsiteFull(website)
}
// UpdateWebsite 更新网站
func (s *Storage) UpdateWebsite(website models.Website) error {
return s.persistWebsiteFull(website)
}
// DeleteWebsite 删除网站
func (s *Storage) DeleteWebsite(id string) error {
return s.db.Transaction(func(tx *gorm.DB) error {
_ = tx.Where("website_id = ?", id).Delete(&MonitorProbeLatest{})
_ = tx.Where("website_id = ?", id).Delete(&MonitorProbeHour{})
_ = tx.Where("website_id = ?", id).Delete(&MonitorProbeDay{})
_ = tx.Where("website_id = ?", id).Delete(&MonitorWebsiteURL{})
_ = tx.Where("website_id = ?", id).Delete(&MonitorWebsiteGroup{})
return tx.Where("id = ?", id).Delete(&MonitorWebsite{}).Error
})
}
// GetGroups 获取所有分组
func (s *Storage) GetGroups() []models.Group {
var rows []MonitorGroup
s.db.Order("sort_order ASC, id ASC").Find(&rows)
out := make([]models.Group, len(rows))
for i, r := range rows {
out[i] = models.Group{ID: r.ID, Name: r.Name}
}
return out
}
// AddGroup 添加分组
func (s *Storage) AddGroup(group models.Group) error {
var n int64
s.db.Model(&MonitorGroup{}).Count(&n)
return s.db.Create(&MonitorGroup{
ID: group.ID,
Name: group.Name,
SortOrder: int(n) + 1,
}).Error
}
// GetGroupByID 按 ID 获取分组（无则 nil）
func (s *Storage) GetGroupByID(id string) *models.Group {
var r MonitorGroup
if err := s.db.First(&r, "id = ?", id).Error; err != nil {
return nil
}
g := models.Group{ID: r.ID, Name: r.Name}
return &g
}
// UpdateGroup 更新分组显示名称（ID 不变）
func (s *Storage) UpdateGroup(id, name string) error {
name = strings.TrimSpace(name)
if name == "" {
return fmt.Errorf("分类名称不能为空")
}
res := s.db.Model(&MonitorGroup{}).Where("id = ?", id).Update("name", name)
if res.Error != nil {
return res.Error
}
if res.RowsAffected == 0 {
return fmt.Errorf("分类不存在")
}
return nil
}
// DeleteGroup 删除分组；从所有网站中移除该分类；若网站无剩余分类则归入删除后列表中的第一个分类。至少保留一个分类。
func (s *Storage) DeleteGroup(id string) error {
var total int64
s.db.Model(&MonitorGroup{}).Count(&total)
if total <= 1 {
return fmt.Errorf("至少保留一个分类")
}
var remain []MonitorGroup
s.db.Where("id != ?", id).Order("sort_order ASC, id ASC").Find(&remain)
if len(remain) == 0 {
return fmt.Errorf("至少保留一个分类")
}
fallbackID := remain[0].ID
var sites []MonitorWebsite
if err := s.db.Preload("GroupLinks").Find(&sites).Error; err != nil {
return err
}
return s.db.Transaction(func(tx *gorm.DB) error {
for i := range sites {
next := make([]string, 0)
for _, l := range sites[i].GroupLinks {
if l.GroupID != id {
next = append(next, l.GroupID)
}
}
if len(next) == 0 {
next = []string{fallbackID}
}
if err := tx.Where("website_id = ?", sites[i].ID).Delete(&MonitorWebsiteGroup{}).Error; err != nil {
return err
}
for _, gid := range next {
if err := tx.Create(&MonitorWebsiteGroup{WebsiteID: sites[i].ID, GroupID: gid}).Error; err != nil {
return err
}
}
}
if err := tx.Delete(&MonitorGroup{}, "id = ?", id).Error; err != nil {
return err
}
return nil
})
}
// SaveAll 周期结束时清理过期汇总分区（日表按 history_days，小时表保留约 10 天）
func (s *Storage) SaveAll() error {
s.purgeProbeRollups()
return nil
}

37
mengyaping-backend/utils/intranet.go Normal file
View File

@@ -0,0 +1,37 @@
package utils
import (
"net"
"net/url"
)
// IsIntranetURL 判断监控地址的主机是否为内网 / 本机 IP（直填 IP 的虚拟局域网站点）。
// 仅识别主机名为 IPv4/IPv6 字面量的情况；公网域名不在此列。
func IsIntranetURL(raw string) bool {
u, err := url.Parse(raw)
if err != nil {
return false
}
host := u.Hostname()
if host == "" {
return false
}
ip := net.ParseIP(host)
if ip == nil {
return false
}
return isIntranetIP(ip)
}
func isIntranetIP(ip net.IP) bool {
if ip.IsLoopback() || ip.IsPrivate() || ip.IsLinkLocalUnicast() {
return true
}
// Go 1.17+ IsPrivate 已含 RFC1918、CGNAT 100.64/10、ULA 等；再兜底部分实现差异
if v4 := ip.To4(); v4 != nil {
if v4[0] == 100 && v4[1] >= 64 && v4[1] <= 127 {
return true
}
}
return false
}

24
mengyaping-backend/utils/intranet_test.go Normal file
View File

@@ -0,0 +1,24 @@
package utils
import "testing"
func TestIsIntranetURL(t *testing.T) {
cases := []struct {
raw string
want bool
}{
{"http://10.0.0.233:8080/path", true},
{"https://192.168.1.1/", true},
{"http://127.0.0.1:3000", true},
{"http://[fd00::1]/", true},
{"https://1.1.1.1/", false},
{"https://example.com/", false},
{"http://nas.local:8080", false},
}
for _, tc := range cases {
got := IsIntranetURL(tc.raw)
if got != tc.want {
t.Fatalf("%q: got %v want %v", tc.raw, got, tc.want)
}
}
}