mirror of
https://github.com/Rain-kl/OpenFlare.git
synced 2026-09-29 22:06:38 +08:00
ryan
365 lines
10 KiB
Go
365 lines
10 KiB
Go
/*
|
|
Copyright 2025 linux.do
|
|
Modified by Arctel.net, 2026
|
|
|
|
Licensed under the Apache License, Version 2.0 (the "License");
|
|
you may not use this file except in compliance with the License.
|
|
You may obtain a copy of the License at
|
|
|
|
http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
Unless required by applicable law or agreed to in writing, software
|
|
distributed under the License is distributed on an "AS IS" BASIS,
|
|
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
See the License for the specific language governing permissions and
|
|
limitations under the License.
|
|
*/
|
|
|
|
// Package status 提供系统状态查询接口
|
|
package status
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"log"
|
|
"math"
|
|
"net/http"
|
|
"os"
|
|
"os/exec"
|
|
"runtime"
|
|
"time"
|
|
|
|
"github.com/Rain-kl/Wavelet/internal/config"
|
|
"github.com/Rain-kl/Wavelet/internal/db"
|
|
"github.com/Rain-kl/Wavelet/internal/util"
|
|
"github.com/gin-gonic/gin"
|
|
)
|
|
|
|
// startTime 记录服务启动时间
|
|
var startTime = time.Now()
|
|
|
|
const (
|
|
hoursInDay = 24
|
|
minutesInHour = 60
|
|
secondsInMinute = 60
|
|
nanosPerSecond = 1e9
|
|
binaryKB = 2
|
|
binaryMB = 3
|
|
binaryGB = 4
|
|
valueThreshold = 10 // 格式化时区分整数显示的阈值
|
|
)
|
|
|
|
// SystemStatusResponse 系统状态响应结构体
|
|
type SystemStatusResponse struct {
|
|
Uptime string `json:"uptime"`
|
|
NumGoroutine int `json:"num_goroutine"`
|
|
Alloc string `json:"alloc"`
|
|
TotalAlloc string `json:"total_alloc"`
|
|
Sys string `json:"sys"`
|
|
Lookups uint64 `json:"lookups"`
|
|
Mallocs uint64 `json:"mallocs"`
|
|
Frees uint64 `json:"frees"`
|
|
HeapAlloc string `json:"heap_alloc"`
|
|
HeapSys string `json:"heap_sys"`
|
|
HeapIdle string `json:"heap_idle"`
|
|
HeapInuse string `json:"heap_inuse"`
|
|
HeapReleased string `json:"heap_released"`
|
|
HeapObjects uint64 `json:"heap_objects"`
|
|
StackInuse string `json:"stack_inuse"`
|
|
StackSys string `json:"stack_sys"`
|
|
MSpanInuse string `json:"mspan_inuse"`
|
|
MSpanSys string `json:"mspan_sys"`
|
|
MCacheInuse string `json:"mcache_inuse"`
|
|
MCacheSys string `json:"mcache_sys"`
|
|
BuckHashSys string `json:"buck_hash_sys"`
|
|
GCSys string `json:"gc_sys"`
|
|
OtherSys string `json:"other_sys"`
|
|
NextGC string `json:"next_gc"`
|
|
LastGCTime string `json:"last_gc_time"`
|
|
PauseTotalNs string `json:"pause_total_ns"`
|
|
LastPause string `json:"last_pause"`
|
|
NumGC uint32 `json:"num_gc"`
|
|
}
|
|
|
|
// formatBytes 格式化字节大小
|
|
func formatBytes(bytes uint64) string {
|
|
const unit = 1024
|
|
if bytes < unit {
|
|
return fmt.Sprintf("%d B", bytes)
|
|
}
|
|
div, exp := int64(unit), 0
|
|
for n := bytes / unit; n >= unit; n /= unit {
|
|
div *= unit
|
|
exp++
|
|
}
|
|
value := float64(bytes) / float64(div)
|
|
var suffix string
|
|
switch exp {
|
|
case binaryKB:
|
|
suffix = "KiB"
|
|
case binaryMB:
|
|
suffix = "MiB"
|
|
case binaryGB:
|
|
suffix = "GiB"
|
|
default:
|
|
suffix = "TiB"
|
|
}
|
|
|
|
// 格式化规则：
|
|
// - 如果是整数（如 16, 73, 105, 986, 112）：
|
|
// - 如果 >= 10，则格式化为 "%.0f" (e.g. "16 KiB")
|
|
// - 如果 < 10，则格式化为 "%.1f" (e.g. "9.0 KiB")
|
|
// - 如果不是整数（如 5.8, 9.1, 7.6, 4.8）：格式化为 "%.1f"
|
|
if value == math.Trunc(value) {
|
|
if value >= valueThreshold {
|
|
return fmt.Sprintf("%.0f %s", value, suffix)
|
|
}
|
|
return fmt.Sprintf("%.1f %s", value, suffix)
|
|
}
|
|
return fmt.Sprintf("%.1f %s", value, suffix)
|
|
}
|
|
|
|
// formatDuration 格式化时间持续时间
|
|
func formatDuration(d time.Duration) string {
|
|
days := int(d.Hours()) / hoursInDay
|
|
hours := int(d.Hours()) % hoursInDay
|
|
minutes := int(d.Minutes()) % minutesInHour
|
|
seconds := int(d.Seconds()) % secondsInMinute
|
|
|
|
var res string
|
|
if days > 0 {
|
|
res += fmt.Sprintf("%d天", days)
|
|
}
|
|
if hours > 0 {
|
|
res += fmt.Sprintf("%d小时", hours)
|
|
}
|
|
if minutes > 0 {
|
|
res += fmt.Sprintf("%d分钟", minutes)
|
|
}
|
|
if seconds > 0 || res == "" {
|
|
res += fmt.Sprintf("%d秒钟", seconds)
|
|
}
|
|
return res
|
|
}
|
|
|
|
// GetSystemStatus 获取系统状态信息
|
|
// @Summary 获取系统状态信息
|
|
// @Description 获取后端服务运行状态、Goroutine、内存指标等详细统计数据，需要管理员权限
|
|
// @Tags admin
|
|
// @Produce json
|
|
// @Security SessionCookie
|
|
// @Success 200 {object} util.ResponseAny{data=status.SystemStatusResponse} "获取成功"
|
|
// @Failure 401 {object} util.ResponseAny "未登录"
|
|
// @Failure 403 {object} util.ResponseAny "无管理员权限"
|
|
// @Router /api/v1/admin/status [get]
|
|
func GetSystemStatus(c *gin.Context) {
|
|
var m runtime.MemStats
|
|
runtime.ReadMemStats(&m)
|
|
|
|
uptime := formatDuration(time.Since(startTime))
|
|
numGoroutine := runtime.NumGoroutine()
|
|
|
|
var lastGCTime string
|
|
if m.LastGC > 0 {
|
|
lastGCTime = formatDuration(time.Since(time.Unix(0, int64(m.LastGC))))
|
|
} else {
|
|
lastGCTime = "无"
|
|
}
|
|
|
|
var lastPause string
|
|
if m.NumGC > 0 {
|
|
lastPause = fmt.Sprintf("%.3fs", float64(m.PauseNs[(m.NumGC-1)%256])/nanosPerSecond)
|
|
} else {
|
|
lastPause = "0.000s"
|
|
}
|
|
|
|
res := SystemStatusResponse{
|
|
Uptime: uptime,
|
|
NumGoroutine: numGoroutine,
|
|
Alloc: formatBytes(m.Alloc),
|
|
TotalAlloc: formatBytes(m.TotalAlloc),
|
|
Sys: formatBytes(m.Sys),
|
|
Lookups: m.Lookups,
|
|
Mallocs: m.Mallocs,
|
|
Frees: m.Frees,
|
|
HeapAlloc: formatBytes(m.HeapAlloc),
|
|
HeapSys: formatBytes(m.HeapSys),
|
|
HeapIdle: formatBytes(m.HeapIdle),
|
|
HeapInuse: formatBytes(m.HeapInuse),
|
|
HeapReleased: formatBytes(m.HeapReleased),
|
|
HeapObjects: m.HeapObjects,
|
|
StackInuse: formatBytes(m.StackInuse),
|
|
StackSys: formatBytes(m.StackSys),
|
|
MSpanInuse: formatBytes(m.MSpanInuse),
|
|
MSpanSys: formatBytes(m.MSpanSys),
|
|
MCacheInuse: formatBytes(m.MCacheInuse),
|
|
MCacheSys: formatBytes(m.MCacheSys),
|
|
BuckHashSys: formatBytes(m.BuckHashSys),
|
|
GCSys: formatBytes(m.GCSys),
|
|
OtherSys: formatBytes(m.OtherSys),
|
|
NextGC: formatBytes(m.NextGC),
|
|
LastGCTime: lastGCTime,
|
|
PauseTotalNs: fmt.Sprintf("%.1fs", float64(m.PauseTotalNs)/nanosPerSecond),
|
|
LastPause: lastPause,
|
|
NumGC: m.NumGC,
|
|
}
|
|
|
|
c.JSON(http.StatusOK, util.OK(res))
|
|
}
|
|
|
|
// DatabaseInfoResponse 数据库信息响应结构体
|
|
type DatabaseInfoResponse struct {
|
|
Type string `json:"type"`
|
|
Name string `json:"name"`
|
|
Version string `json:"version"`
|
|
}
|
|
|
|
// getSQLiteInfo 返回 SQLite 数据库信息
|
|
func getSQLiteInfo(ctx context.Context) DatabaseInfoResponse {
|
|
info := DatabaseInfoResponse{
|
|
Type: "sqlite",
|
|
Name: config.Config.Database.SQLitePath,
|
|
Version: "SQLite",
|
|
}
|
|
if info.Name == "" {
|
|
info.Name = "./data/wavelet.db"
|
|
}
|
|
gormDB := db.DB(ctx)
|
|
if gormDB == nil {
|
|
return info
|
|
}
|
|
var ver string
|
|
if err := gormDB.Raw("SELECT sqlite_version()").Scan(&ver).Error; err == nil && ver != "" {
|
|
info.Version = "SQLite " + ver
|
|
}
|
|
return info
|
|
}
|
|
|
|
// getPostgresInfo 返回 PostgreSQL 数据库信息
|
|
func getPostgresInfo(ctx context.Context) DatabaseInfoResponse {
|
|
info := DatabaseInfoResponse{
|
|
Type: "postgres",
|
|
Name: config.Config.Database.Database,
|
|
Version: "PostgreSQL",
|
|
}
|
|
gormDB := db.DB(ctx)
|
|
if gormDB == nil {
|
|
return info
|
|
}
|
|
var ver string
|
|
if err := gormDB.Raw("SELECT version()").Scan(&ver).Error; err == nil && ver != "" {
|
|
info.Version = ver
|
|
}
|
|
return info
|
|
}
|
|
|
|
// GetDatabaseInfo 获取当前数据库类型及版本信息
|
|
// @Summary 获取数据库信息
|
|
// @Description 返回当前使用的数据库类型（sqlite/postgres）、名称/路径及版本字符串，需要管理员权限
|
|
// @Tags admin
|
|
// @Produce json
|
|
// @Security SessionCookie
|
|
// @Success 200 {object} util.ResponseAny{data=status.DatabaseInfoResponse} "获取成功"
|
|
// @Failure 401 {object} util.ResponseAny "未登录"
|
|
// @Failure 403 {object} util.ResponseAny "无管理员权限"
|
|
// @Router /api/v1/admin/db-info [get]
|
|
func GetDatabaseInfo(c *gin.Context) {
|
|
var info DatabaseInfoResponse
|
|
if !config.Config.Database.Enabled {
|
|
info = getSQLiteInfo(c.Request.Context())
|
|
} else {
|
|
info = getPostgresInfo(c.Request.Context())
|
|
}
|
|
c.JSON(http.StatusOK, util.OK(info))
|
|
}
|
|
|
|
// ExportDatabase 导出数据库
|
|
// @Summary 导出数据库
|
|
// @Description SQLite 时直接下载 .db 文件；PostgreSQL 时执行 pg_dump 并流式下载 .sql 文件，需要管理员权限
|
|
// @Tags admin
|
|
// @Produce application/octet-stream
|
|
// @Security SessionCookie
|
|
// @Success 200 {file} binary "数据库文件"
|
|
// @Failure 401 {object} util.ResponseAny "未登录"
|
|
// @Failure 403 {object} util.ResponseAny "无管理员权限"
|
|
// @Failure 500 {object} util.ResponseAny "导出失败"
|
|
// @Router /api/v1/admin/db-export [get]
|
|
func ExportDatabase(c *gin.Context) {
|
|
if !config.Config.Database.Enabled {
|
|
exportSQLite(c)
|
|
} else {
|
|
exportPostgres(c)
|
|
}
|
|
}
|
|
|
|
// exportSQLite 以 HTTP 附件方式下载 SQLite .db 文件
|
|
func exportSQLite(c *gin.Context) {
|
|
path := config.Config.Database.SQLitePath
|
|
if path == "" {
|
|
path = "./data/wavelet.db"
|
|
}
|
|
|
|
f, err := os.Open(path)
|
|
if err != nil {
|
|
c.JSON(http.StatusInternalServerError, util.Err("无法打开数据库文件: "+err.Error()))
|
|
return
|
|
}
|
|
defer func() {
|
|
if closeErr := f.Close(); closeErr != nil {
|
|
_ = closeErr
|
|
}
|
|
}()
|
|
|
|
fi, err := f.Stat()
|
|
if err != nil {
|
|
c.JSON(http.StatusInternalServerError, util.Err("无法读取数据库文件信息: "+err.Error()))
|
|
return
|
|
}
|
|
|
|
c.Header("Content-Disposition", `attachment; filename="wavelet.db"`)
|
|
c.Header("Content-Type", "application/octet-stream")
|
|
c.Header("Content-Length", fmt.Sprintf("%d", fi.Size()))
|
|
c.Status(http.StatusOK)
|
|
http.ServeContent(c.Writer, c.Request, "wavelet.db", fi.ModTime(), f)
|
|
}
|
|
|
|
// exportPostgres 执行 pg_dump 并将输出流式传输给客户端
|
|
func exportPostgres(c *gin.Context) {
|
|
dbCfg := config.Config.Database
|
|
|
|
// 检查 pg_dump 是否可用
|
|
pgDumpPath, err := exec.LookPath("pg_dump")
|
|
if err != nil {
|
|
c.JSON(http.StatusInternalServerError, util.Err("pg_dump 不可用，请确保服务器已安装 PostgreSQL 客户端工具"))
|
|
return
|
|
}
|
|
|
|
args := []string{
|
|
"--no-password",
|
|
"-h", dbCfg.Host,
|
|
"-p", fmt.Sprintf("%d", dbCfg.Port),
|
|
"-U", dbCfg.Username,
|
|
dbCfg.Database,
|
|
}
|
|
|
|
cmd := exec.CommandContext(c.Request.Context(), pgDumpPath, args...)
|
|
if dbCfg.Password != "" {
|
|
cmd.Env = append(os.Environ(), "PGPASSWORD="+dbCfg.Password)
|
|
} else {
|
|
cmd.Env = os.Environ()
|
|
}
|
|
|
|
fileName := fmt.Sprintf("wavelet_%s.sql", time.Now().Format("20060102_150405"))
|
|
c.Header("Content-Disposition", `attachment; filename="`+fileName+`"`)
|
|
c.Header("Content-Type", "application/octet-stream")
|
|
c.Status(http.StatusOK)
|
|
|
|
cmd.Stdout = c.Writer
|
|
cmd.Stderr = nil // 忽略 stderr 以避免污染输出流
|
|
|
|
if err := cmd.Run(); err != nil {
|
|
// 响应头已发出，无法再写 JSON 错误，记录到服务器日志
|
|
log.Printf("[db-export] pg_dump failed: %v\n", err)
|
|
}
|
|
}
|