232 lines
7.4 KiB
Go
232 lines
7.4 KiB
Go
package api
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"math"
|
|
"net/http"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"sync"
|
|
"time"
|
|
|
|
"github.com/havline/havline/internal/acme"
|
|
certstore "github.com/havline/havline/internal/certificate"
|
|
"github.com/havline/havline/internal/cloudflared"
|
|
"github.com/havline/havline/internal/config"
|
|
"github.com/havline/havline/internal/ddns"
|
|
"github.com/havline/havline/internal/logstore"
|
|
"github.com/havline/havline/internal/publicip"
|
|
"github.com/havline/havline/internal/service"
|
|
"github.com/havline/havline/internal/sysinfo"
|
|
)
|
|
|
|
type StatusHandler struct {
|
|
cfg config.Config
|
|
proxySvc *service.ProxyService
|
|
ddnsSvc *ddns.Service
|
|
acmeSvc *acme.Service
|
|
cloudflareSvc *cloudflared.Service
|
|
startedAt string
|
|
nginxPIDFile string
|
|
cpuMu sync.Mutex
|
|
cpuSample sysinfo.CPUSample
|
|
}
|
|
|
|
func NewStatusHandler(cfg config.Config, proxySvc *service.ProxyService, ddnsSvc *ddns.Service, acmeSvc *acme.Service, cloudflareSvc *cloudflared.Service, startedAt, nginxPIDFile string) *StatusHandler {
|
|
// 先采一次 CPU 计数器，使首次请求就能算出占用率（否则只能返回 0）
|
|
_, sample := sysinfo.Read(sysinfo.CPUSample{})
|
|
return &StatusHandler{
|
|
cfg: cfg,
|
|
proxySvc: proxySvc,
|
|
ddnsSvc: ddnsSvc,
|
|
acmeSvc: acmeSvc,
|
|
cloudflareSvc: cloudflareSvc,
|
|
startedAt: startedAt,
|
|
nginxPIDFile: nginxPIDFile,
|
|
cpuSample: sample,
|
|
}
|
|
}
|
|
|
|
type statusResponse struct {
|
|
PublicIPv4 string `json:"public_ipv4"`
|
|
PublicIPv6 string `json:"public_ipv6"`
|
|
PublicIPSource string `json:"public_ip_source"`
|
|
DDNSStatus string `json:"ddns_status"`
|
|
DDNSCount int `json:"ddns_count"`
|
|
DDNSLastUpdated string `json:"ddns_last_updated,omitempty"`
|
|
CertificateStatus string `json:"certificate_status"`
|
|
CertificateDays int `json:"certificate_days"`
|
|
CertificateCount int `json:"certificate_count"`
|
|
CertificateSummary string `json:"certificate_summary,omitempty"`
|
|
ProxyCount int `json:"proxy_count"`
|
|
NginxStatus string `json:"nginx_status"`
|
|
RequestToday int `json:"request_today"`
|
|
RequestYesterday int `json:"request_yesterday"`
|
|
RequestTrend *int `json:"request_trend,omitempty"`
|
|
RequestsHourly []int `json:"requests_hourly"`
|
|
RequestsHourlyLabels []string `json:"requests_hourly_labels"`
|
|
ErrorToday int `json:"error_today"`
|
|
AvgResponseMs float64 `json:"avg_response_ms"`
|
|
CPUPercent float64 `json:"cpu_percent"`
|
|
MemUsedBytes uint64 `json:"mem_used_bytes"`
|
|
MemTotalBytes uint64 `json:"mem_total_bytes"`
|
|
DiskUsedBytes uint64 `json:"disk_used_bytes"`
|
|
DiskTotalBytes uint64 `json:"disk_total_bytes"`
|
|
CloudflareCount int `json:"cloudflare_count"`
|
|
CloudflareOnline int `json:"cloudflare_online"`
|
|
CloudflareStatus string `json:"cloudflare_status"`
|
|
CloudflareMessage string `json:"cloudflare_message,omitempty"`
|
|
StartedAt string `json:"started_at"`
|
|
UptimeSeconds int64 `json:"uptime_seconds"`
|
|
}
|
|
|
|
func (h *StatusHandler) Get(w http.ResponseWriter, r *http.Request) {
|
|
rules, err := h.proxySvc.List(r.Context())
|
|
if err != nil {
|
|
writeError(r, w, http.StatusInternalServerError, "读取状态失败")
|
|
return
|
|
}
|
|
|
|
nginxStatus := "unknown"
|
|
if _, err := os.Stat(h.nginxPIDFile); err == nil {
|
|
nginxStatus = "running"
|
|
} else if os.IsNotExist(err) {
|
|
nginxStatus = "stopped"
|
|
}
|
|
|
|
ddnsStatus, ddnsLastUpdated, ddnsCount := h.ddnsSvc.Summary(r.Context())
|
|
ipv4, ipv6, ipSource := h.resolvePublicIPs(r.Context())
|
|
|
|
records, _ := h.acmeSvc.List(r.Context())
|
|
certStatus, certDays, certCount, certSummary := summarizeCertificates(records)
|
|
|
|
resources, cpuSample := sysinfo.Read(h.currentCPUSample())
|
|
h.setCPUSample(cpuSample)
|
|
cfSummary := cloudflared.TunnelSummary{Status: "none", Message: "未创建隧道"}
|
|
if h.cloudflareSvc != nil {
|
|
cfSummary = h.cloudflareSvc.Summary(r.Context())
|
|
}
|
|
|
|
accessLog := filepath.Join(h.cfg.LogsDir(), "access.log")
|
|
total, errors, avgMs := logstore.CountTodayAccess(accessLog)
|
|
yesterday, _, _ := logstore.CountAccessForDay(accessLog, time.Now().AddDate(0, 0, -1))
|
|
hourly, hourlyLabels := logstore.HourlyAccessCounts(accessLog)
|
|
|
|
started, _ := time.Parse(time.RFC3339, h.startedAt)
|
|
uptime := time.Since(started).Seconds()
|
|
|
|
writeJSON(w, http.StatusOK, statusResponse{
|
|
PublicIPv4: ipv4,
|
|
PublicIPv6: ipv6,
|
|
PublicIPSource: ipSource,
|
|
DDNSStatus: ddnsStatus,
|
|
DDNSCount: ddnsCount,
|
|
DDNSLastUpdated: ddnsLastUpdated,
|
|
CertificateStatus: certStatus,
|
|
CertificateDays: certDays,
|
|
CertificateCount: certCount,
|
|
CertificateSummary: certSummary,
|
|
ProxyCount: len(rules),
|
|
NginxStatus: nginxStatus,
|
|
RequestToday: total,
|
|
RequestYesterday: yesterday,
|
|
RequestTrend: requestTrendPercent(total, yesterday),
|
|
RequestsHourly: hourly,
|
|
RequestsHourlyLabels: hourlyLabels,
|
|
ErrorToday: errors,
|
|
AvgResponseMs: avgMs,
|
|
CPUPercent: resources.CPUPercent,
|
|
MemUsedBytes: resources.MemUsedBytes,
|
|
MemTotalBytes: resources.MemTotalBytes,
|
|
DiskUsedBytes: resources.DiskUsedBytes,
|
|
DiskTotalBytes: resources.DiskTotalBytes,
|
|
CloudflareCount: cfSummary.Count,
|
|
CloudflareOnline: cfSummary.Online,
|
|
CloudflareStatus: cfSummary.Status,
|
|
CloudflareMessage: cfSummary.Message,
|
|
StartedAt: h.startedAt,
|
|
UptimeSeconds: int64(uptime),
|
|
})
|
|
}
|
|
|
|
// currentCPUSample 与 setCPUSample 用锁保护上次采样，/api/status 可能被并发调用
|
|
func (h *StatusHandler) currentCPUSample() sysinfo.CPUSample {
|
|
h.cpuMu.Lock()
|
|
defer h.cpuMu.Unlock()
|
|
return h.cpuSample
|
|
}
|
|
|
|
func (h *StatusHandler) setCPUSample(sample sysinfo.CPUSample) {
|
|
h.cpuMu.Lock()
|
|
defer h.cpuMu.Unlock()
|
|
h.cpuSample = sample
|
|
}
|
|
|
|
func (h *StatusHandler) resolvePublicIPs(ctx context.Context) (ipv4, ipv6, source string) {
|
|
if ipv4, ipv6, ok := h.ddnsSvc.PublicIPs(ctx); ok {
|
|
return ipv4, ipv6, "ddns"
|
|
}
|
|
if ipv4, ipv6, ok := h.ddnsSvc.LastKnownPublicIPs(ctx); ok {
|
|
return ipv4, ipv6, "ddns"
|
|
}
|
|
detectCtx, cancel := context.WithTimeout(ctx, 3*time.Second)
|
|
defer cancel()
|
|
ipv4, ipv6, err := publicip.Detect(detectCtx)
|
|
if err != nil {
|
|
return "", ipv6, "none"
|
|
}
|
|
return ipv4, ipv6, "detect"
|
|
}
|
|
|
|
func summarizeCertificates(records []certstore.Record) (status string, days int, count int, summary string) {
|
|
if len(records) == 0 {
|
|
return "none", 0, 0, ""
|
|
}
|
|
count = len(records)
|
|
status = "ok"
|
|
days = records[0].DaysLeft
|
|
for _, rec := range records {
|
|
if rec.DaysLeft < days {
|
|
days = rec.DaysLeft
|
|
}
|
|
switch {
|
|
case rec.Status == "error" || rec.DaysLeft <= 0:
|
|
status = "error"
|
|
case rec.DaysLeft <= 30 && status != "error":
|
|
status = "warning"
|
|
}
|
|
}
|
|
if count == 1 {
|
|
summary = certificateSummaryName(records[0])
|
|
} else {
|
|
summary = fmt.Sprintf("%d 张证书", count)
|
|
}
|
|
return status, days, count, summary
|
|
}
|
|
|
|
func requestTrendPercent(today, yesterday int) *int {
|
|
if yesterday <= 0 {
|
|
if today <= 0 {
|
|
return nil
|
|
}
|
|
v := 100
|
|
return &v
|
|
}
|
|
v := int(math.Round(float64(today-yesterday) / float64(yesterday) * 100))
|
|
return &v
|
|
}
|
|
|
|
func certificateSummaryName(rec certstore.Record) string {
|
|
for _, domain := range rec.Domains {
|
|
if strings.HasPrefix(domain, "*.") {
|
|
return domain
|
|
}
|
|
}
|
|
if rec.Wildcard {
|
|
return "*." + rec.Domain
|
|
}
|
|
return rec.Domain
|
|
}
|