mrlee
862442e77f
- 配置版本：fsutil 版本化备份（内容相同自动去重），主 nginx.conf 与 VPS vhost 的版本列表/逐行差异/一键回滚，回滚先校验语法与 nginx -t 再写回 - agent 0.12.2：写 vhost 前留版本；nginx -t 校验失败改为恢复上一个可用版本（此前直接删文件），新增域名 vhost 版本端点，双架构二进制已重编 - 通知：补企业微信 / 钉钉 / 飞书机器人，切换预设时服务地址跟随该预设默认值 - 阈值告警：新增 internal/monitor 巡检（CPU/内存/磁盘持续超阈值、隧道连续 N 次未注册），默认关闭，带静默期与恢复通知 - API Token：api_tokens 表 + Authorization Bearer 认证，只读/读写两种范围；令牌管理与改密/退出仅限登录会话
419 lines
12 KiB
Go
419 lines
12 KiB
Go
package service
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"strings"
|
|
|
|
"github.com/fonu/fonu/internal/nginx"
|
|
"github.com/fonu/fonu/internal/proxy"
|
|
"github.com/fonu/fonu/internal/settings"
|
|
)
|
|
|
|
type NginxBackupInfo struct {
|
|
Name string `json:"name"`
|
|
CreatedAt string `json:"created_at"`
|
|
}
|
|
|
|
type RuleNginxView struct {
|
|
Mode string `json:"mode"`
|
|
Enabled bool `json:"enabled"`
|
|
Active bool `json:"active"`
|
|
Generated string `json:"generated"`
|
|
Content string `json:"content"`
|
|
Backups []NginxBackupInfo `json:"backups"`
|
|
}
|
|
|
|
type GlobalNginxView struct {
|
|
Mode string `json:"mode"`
|
|
GeneratedFramework string `json:"generated_framework"`
|
|
GeneratedSnippet string `json:"generated_snippet"`
|
|
Content string `json:"content"`
|
|
Backups []NginxBackupInfo `json:"backups"`
|
|
}
|
|
|
|
type SaveRuleNginxInput struct {
|
|
Mode string
|
|
Content *string
|
|
}
|
|
|
|
type SaveGlobalNginxInput struct {
|
|
Mode string
|
|
Content *string
|
|
}
|
|
|
|
func (s *ProxyService) GetRuleNginx(ctx context.Context, id int64) (RuleNginxView, error) {
|
|
rule, err := s.Get(ctx, id)
|
|
if err != nil {
|
|
return RuleNginxView{}, err
|
|
}
|
|
certs, err := s.loadCertSources(ctx)
|
|
if err != nil {
|
|
return RuleNginxView{}, err
|
|
}
|
|
opts := s.loadGenerateOptions(ctx)
|
|
generated, err := nginx.GenerateRuleBlocks(s.cfg, rule, certs, opts)
|
|
if err != nil {
|
|
return RuleNginxView{}, err
|
|
}
|
|
mode := rule.NginxMode
|
|
if mode == "" {
|
|
mode = "auto"
|
|
}
|
|
content := generated
|
|
if mode == "custom" {
|
|
custom, err := nginx.ReadRuleCustom(s.cfg, id)
|
|
if err != nil {
|
|
return RuleNginxView{}, err
|
|
}
|
|
if strings.TrimSpace(custom) != "" {
|
|
content = custom
|
|
}
|
|
}
|
|
backups, err := nginx.ListBackups(s.cfg.NginxRuleBackupsDir(id))
|
|
if err != nil {
|
|
return RuleNginxView{}, err
|
|
}
|
|
return RuleNginxView{
|
|
Mode: mode,
|
|
Enabled: rule.Enabled,
|
|
Active: rule.Enabled,
|
|
Generated: generated,
|
|
Content: content,
|
|
Backups: mapBackups(backups),
|
|
}, nil
|
|
}
|
|
|
|
func (s *ProxyService) SaveRuleNginx(ctx context.Context, id int64, in SaveRuleNginxInput) (RuleNginxView, error) {
|
|
rule, err := s.Get(ctx, id)
|
|
if err != nil {
|
|
return RuleNginxView{}, err
|
|
}
|
|
mode := strings.TrimSpace(in.Mode)
|
|
if mode == "" {
|
|
mode = rule.NginxMode
|
|
}
|
|
if mode != "auto" && mode != "custom" {
|
|
return RuleNginxView{}, fmt.Errorf("无效的 nginx 模式")
|
|
}
|
|
|
|
if mode == "auto" {
|
|
if err := s.store.SetNginxMode(ctx, id, "auto"); err != nil {
|
|
return RuleNginxView{}, err
|
|
}
|
|
// 切回自动模式后，手动配置的占用记录不再适用
|
|
if err := s.store.ClearCustomEndpoints(ctx, id); err != nil {
|
|
return RuleNginxView{}, err
|
|
}
|
|
if err := s.applyNginx(ctx); err != nil {
|
|
return RuleNginxView{}, err
|
|
}
|
|
return s.GetRuleNginx(ctx, id)
|
|
}
|
|
|
|
if in.Content == nil {
|
|
return RuleNginxView{}, fmt.Errorf("手动模式需要提供配置内容")
|
|
}
|
|
content := *in.Content
|
|
if strings.TrimSpace(content) == "" {
|
|
return RuleNginxView{}, fmt.Errorf("Nginx 配置不能为空")
|
|
}
|
|
|
|
if err := s.validateRuleNginxPending(ctx, rule, content); err != nil {
|
|
return RuleNginxView{}, err
|
|
}
|
|
// 手动配置里的 listen/server_name 不进 proxy_hosts，需单独解析记录并校验占用，
|
|
// 否则它与其它规则的同域名同端口冲突只会在 Nginx reload 时静默失效
|
|
endpoints := nginx.ParseServerEndpoints(content)
|
|
if err := s.store.EnsureEndpointsAvailable(ctx, endpoints, id); err != nil {
|
|
return RuleNginxView{}, err
|
|
}
|
|
if _, err := nginx.SaveRuleCustomWithBackup(s.cfg, id, content); err != nil {
|
|
return RuleNginxView{}, err
|
|
}
|
|
if err := s.store.ReplaceCustomEndpoints(ctx, id, endpoints); err != nil {
|
|
return RuleNginxView{}, err
|
|
}
|
|
if err := s.store.SetNginxMode(ctx, id, "custom"); err != nil {
|
|
return RuleNginxView{}, err
|
|
}
|
|
if err := s.applyNginx(ctx); err != nil {
|
|
return RuleNginxView{}, err
|
|
}
|
|
return s.GetRuleNginx(ctx, id)
|
|
}
|
|
|
|
func (s *ProxyService) RollbackRuleNginx(ctx context.Context, id int64, backupName string) (RuleNginxView, error) {
|
|
if _, err := s.Get(ctx, id); err != nil {
|
|
return RuleNginxView{}, err
|
|
}
|
|
backups, err := nginx.ListBackups(s.cfg.NginxRuleBackupsDir(id))
|
|
if err != nil {
|
|
return RuleNginxView{}, err
|
|
}
|
|
if len(backups) == 0 {
|
|
return RuleNginxView{}, fmt.Errorf("没有可回滚的备份")
|
|
}
|
|
if backupName == "" {
|
|
backupName = backups[0].Name
|
|
}
|
|
if err := nginx.RestoreBackup(s.cfg.NginxRuleBackupsDir(id), backupName, s.cfg.NginxRuleCustomPath(id)); err != nil {
|
|
return RuleNginxView{}, err
|
|
}
|
|
custom, err := nginx.ReadRuleCustom(s.cfg, id)
|
|
if err != nil {
|
|
return RuleNginxView{}, err
|
|
}
|
|
rule, err := s.Get(ctx, id)
|
|
if err != nil {
|
|
return RuleNginxView{}, err
|
|
}
|
|
if err := s.validateRuleNginxPending(ctx, rule, custom); err != nil {
|
|
return RuleNginxView{}, err
|
|
}
|
|
endpoints := nginx.ParseServerEndpoints(custom)
|
|
if err := s.store.EnsureEndpointsAvailable(ctx, endpoints, id); err != nil {
|
|
// 备份文件已写回（与原有行为一致），占用记录需跟磁盘内容保持一致，避免留下过期占用
|
|
_ = s.store.ReplaceCustomEndpoints(ctx, id, endpoints)
|
|
return RuleNginxView{}, err
|
|
}
|
|
if err := s.store.ReplaceCustomEndpoints(ctx, id, endpoints); err != nil {
|
|
return RuleNginxView{}, err
|
|
}
|
|
if err := s.store.SetNginxMode(ctx, id, "custom"); err != nil {
|
|
return RuleNginxView{}, err
|
|
}
|
|
if err := s.applyNginx(ctx); err != nil {
|
|
return RuleNginxView{}, err
|
|
}
|
|
return s.GetRuleNginx(ctx, id)
|
|
}
|
|
|
|
func (s *ProxyService) GetGlobalNginx(ctx context.Context) (GlobalNginxView, error) {
|
|
mode, err := s.settings.Get(ctx, settings.KeyNginxGlobalMode)
|
|
if err != nil {
|
|
return GlobalNginxView{}, err
|
|
}
|
|
if mode == "" {
|
|
mode = "auto"
|
|
}
|
|
content, err := nginx.ReadGlobalCustom(s.cfg)
|
|
if err != nil {
|
|
return GlobalNginxView{}, err
|
|
}
|
|
backups, err := nginx.ListBackups(s.cfg.NginxGlobalBackupsDir())
|
|
if err != nil {
|
|
return GlobalNginxView{}, err
|
|
}
|
|
return GlobalNginxView{
|
|
Mode: mode,
|
|
GeneratedFramework: nginx.GenerateGlobalFramework(s.cfg),
|
|
GeneratedSnippet: nginx.DefaultGlobalHTTPSnippet(),
|
|
Content: content,
|
|
Backups: mapBackups(backups),
|
|
}, nil
|
|
}
|
|
|
|
func (s *ProxyService) SaveGlobalNginx(ctx context.Context, in SaveGlobalNginxInput) (GlobalNginxView, error) {
|
|
mode := strings.TrimSpace(in.Mode)
|
|
if mode == "" {
|
|
var err error
|
|
mode, err = s.settings.Get(ctx, settings.KeyNginxGlobalMode)
|
|
if err != nil {
|
|
return GlobalNginxView{}, err
|
|
}
|
|
}
|
|
if mode != "auto" && mode != "custom" {
|
|
return GlobalNginxView{}, fmt.Errorf("无效的 nginx 模式")
|
|
}
|
|
|
|
if mode == "auto" {
|
|
if err := s.settings.Set(ctx, settings.KeyNginxGlobalMode, "auto"); err != nil {
|
|
return GlobalNginxView{}, err
|
|
}
|
|
if err := s.applyNginx(ctx); err != nil {
|
|
return GlobalNginxView{}, err
|
|
}
|
|
return s.GetGlobalNginx(ctx)
|
|
}
|
|
|
|
if in.Content == nil {
|
|
return GlobalNginxView{}, fmt.Errorf("手动模式需要提供配置内容")
|
|
}
|
|
content := *in.Content
|
|
if err := s.validateGlobalNginxPending(ctx, content); err != nil {
|
|
return GlobalNginxView{}, err
|
|
}
|
|
if _, err := nginx.SaveGlobalCustomWithBackup(s.cfg, content); err != nil {
|
|
return GlobalNginxView{}, err
|
|
}
|
|
if err := s.settings.Set(ctx, settings.KeyNginxGlobalMode, "custom"); err != nil {
|
|
return GlobalNginxView{}, err
|
|
}
|
|
if err := s.applyNginx(ctx); err != nil {
|
|
return GlobalNginxView{}, err
|
|
}
|
|
return s.GetGlobalNginx(ctx)
|
|
}
|
|
|
|
func (s *ProxyService) RollbackGlobalNginx(ctx context.Context, backupName string) (GlobalNginxView, error) {
|
|
backups, err := nginx.ListBackups(s.cfg.NginxGlobalBackupsDir())
|
|
if err != nil {
|
|
return GlobalNginxView{}, err
|
|
}
|
|
if len(backups) == 0 {
|
|
return GlobalNginxView{}, fmt.Errorf("没有可回滚的备份")
|
|
}
|
|
if backupName == "" {
|
|
backupName = backups[0].Name
|
|
}
|
|
if err := nginx.RestoreBackup(s.cfg.NginxGlobalBackupsDir(), backupName, s.cfg.NginxGlobalCustomPath()); err != nil {
|
|
return GlobalNginxView{}, err
|
|
}
|
|
content, err := nginx.ReadGlobalCustom(s.cfg)
|
|
if err != nil {
|
|
return GlobalNginxView{}, err
|
|
}
|
|
if err := s.validateGlobalNginxPending(ctx, content); err != nil {
|
|
return GlobalNginxView{}, err
|
|
}
|
|
if err := s.settings.Set(ctx, settings.KeyNginxGlobalMode, "custom"); err != nil {
|
|
return GlobalNginxView{}, err
|
|
}
|
|
if err := s.applyNginx(ctx); err != nil {
|
|
return GlobalNginxView{}, err
|
|
}
|
|
return s.GetGlobalNginx(ctx)
|
|
}
|
|
|
|
func (s *ProxyService) validateRuleNginxPending(ctx context.Context, rule proxy.Rule, content string) error {
|
|
rules, err := s.store.ListEnabled(ctx)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
merged := make([]proxy.Rule, 0, len(rules))
|
|
found := false
|
|
for _, r := range rules {
|
|
if r.ID == rule.ID {
|
|
ruleCopy := rule
|
|
ruleCopy.NginxMode = "custom"
|
|
ruleCopy.Enabled = true
|
|
merged = append(merged, ruleCopy)
|
|
found = true
|
|
continue
|
|
}
|
|
merged = append(merged, r)
|
|
}
|
|
if !found && rule.Enabled {
|
|
ruleCopy := rule
|
|
ruleCopy.NginxMode = "custom"
|
|
merged = append(merged, ruleCopy)
|
|
}
|
|
return s.validateWithOverrides(ctx, merged, nginx.GenerateOptions{
|
|
RuleCustomOverrides: map[int64]string{rule.ID: content},
|
|
})
|
|
}
|
|
|
|
func (s *ProxyService) validateGlobalNginxPending(ctx context.Context, content string) error {
|
|
rules, err := s.store.ListEnabled(ctx)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return s.validateWithOverrides(ctx, rules, nginx.GenerateOptions{
|
|
GlobalCustomOverride: content,
|
|
})
|
|
}
|
|
|
|
func (s *ProxyService) validateWithOverrides(ctx context.Context, rules []proxy.Rule, extra nginx.GenerateOptions) error {
|
|
certs, err := s.loadCertSources(ctx)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
opts := s.loadGenerateOptions(ctx)
|
|
opts.GlobalCustomOverride = extra.GlobalCustomOverride
|
|
opts.GlobalCustomPathOverride = extra.GlobalCustomPathOverride
|
|
opts.RuleCustomOverrides = extra.RuleCustomOverrides
|
|
opts.ChinaCIDRAvailable = nginx.ChinaCIDRExists(s.cfg)
|
|
content, err := nginx.Generate(s.cfg, rules, certs, opts)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return s.nginx.ValidateContent(ctx, content)
|
|
}
|
|
|
|
func mapBackups(entries []nginx.BackupEntry) []NginxBackupInfo {
|
|
out := make([]NginxBackupInfo, 0, len(entries))
|
|
for _, entry := range entries {
|
|
out = append(out, NginxBackupInfo{
|
|
Name: entry.Name,
|
|
CreatedAt: entry.CreatedAt.Format("2006-01-02T15:04:05Z"),
|
|
})
|
|
}
|
|
return out
|
|
}
|
|
|
|
// NginxConfigVersionInfo 描述主配置（nginx.conf）的一个历史版本。
|
|
type NginxConfigVersionInfo struct {
|
|
Name string `json:"name"`
|
|
Size int64 `json:"size"`
|
|
CreatedAt string `json:"created_at"`
|
|
}
|
|
|
|
type NginxConfigVersionsView struct {
|
|
Message string `json:"message,omitempty"`
|
|
Content string `json:"content"`
|
|
Versions []NginxConfigVersionInfo `json:"versions"`
|
|
}
|
|
|
|
type NginxConfigVersionView struct {
|
|
Name string `json:"name"`
|
|
Content string `json:"content"`
|
|
}
|
|
|
|
// GetNginxConfigVersions 返回当前主配置与其历史版本，前端拿两者做差异对比。
|
|
func (s *ProxyService) GetNginxConfigVersions() (NginxConfigVersionsView, error) {
|
|
content, err := s.nginx.ReadConfig()
|
|
if err != nil {
|
|
return NginxConfigVersionsView{}, err
|
|
}
|
|
versions, err := s.nginx.ListConfigVersions()
|
|
if err != nil {
|
|
return NginxConfigVersionsView{}, err
|
|
}
|
|
return NginxConfigVersionsView{Content: content, Versions: mapConfigVersions(versions)}, nil
|
|
}
|
|
|
|
func (s *ProxyService) ReadNginxConfigVersion(name string) (NginxConfigVersionView, error) {
|
|
content, err := s.nginx.ReadConfigVersion(name)
|
|
if err != nil {
|
|
return NginxConfigVersionView{}, err
|
|
}
|
|
return NginxConfigVersionView{Name: name, Content: content}, nil
|
|
}
|
|
|
|
// RollbackNginxConfigVersion 回滚主配置；校验不过时 nginx 层不会动磁盘上的当前配置。
|
|
func (s *ProxyService) RollbackNginxConfigVersion(ctx context.Context, name string) (NginxConfigVersionsView, error) {
|
|
result, err := s.nginx.RollbackConfigVersion(ctx, name)
|
|
if err != nil {
|
|
return NginxConfigVersionsView{}, err
|
|
}
|
|
view, err := s.GetNginxConfigVersions()
|
|
if err != nil {
|
|
return NginxConfigVersionsView{}, err
|
|
}
|
|
view.Message = result.Message
|
|
return view, nil
|
|
}
|
|
|
|
func mapConfigVersions(entries []nginx.ConfigVersion) []NginxConfigVersionInfo {
|
|
out := make([]NginxConfigVersionInfo, 0, len(entries))
|
|
for _, entry := range entries {
|
|
out = append(out, NginxConfigVersionInfo{
|
|
Name: entry.Name,
|
|
Size: entry.Size,
|
|
CreatedAt: entry.CreatedAt.Format("2006-01-02T15:04:05Z"),
|
|
})
|
|
}
|
|
return out
|
|
}
|