完成Scert首轮基础骨架开发与复审
This commit is contained in:
commit
fd8d8608f5
41 files changed
+6987
No files matched your search
@@ -0,0 +1,79 @@
|
||||
package app
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
"log/slog"
|
||||
"time"
|
||||
|
||||
"git.pcux.cn/xuans/Scert/backend/internal/config"
|
||||
"git.pcux.cn/xuans/Scert/backend/internal/database"
|
||||
"git.pcux.cn/xuans/Scert/backend/internal/httpapi"
|
||||
"git.pcux.cn/xuans/Scert/backend/internal/logging"
|
||||
"git.pcux.cn/xuans/Scert/backend/internal/repository"
|
||||
)
|
||||
|
||||
type App struct {
|
||||
Config config.Config
|
||||
Logger *logging.Logger
|
||||
Database *database.Database
|
||||
Repository *repository.SQLDomainRepository
|
||||
HTTP *httpapi.Server
|
||||
}
|
||||
|
||||
func New(ctx context.Context, cfg config.Config) (*App, error) {
|
||||
if err := cfg.Validate(); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
for _, path := range []string{cfg.Paths.Install, cfg.Paths.Certificate, cfg.Paths.Config, cfg.Paths.Data, cfg.Paths.Log, cfg.Paths.Backup} {
|
||||
if err := makeDirectory(path); err != nil {
|
||||
return nil, fmt.Errorf("创建运行目录失败:%w", err)
|
||||
}
|
||||
}
|
||||
logger, err := logging.New(cfg.Paths.Log, slog.LevelInfo)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("初始化日志失败:%w", err)
|
||||
}
|
||||
db, err := database.Open(ctx, cfg.Database)
|
||||
if err != nil {
|
||||
_ = logger.Close()
|
||||
return nil, err
|
||||
}
|
||||
if err := database.Migrate(ctx, db.DB, cfg.Database.Driver); err != nil {
|
||||
_ = db.Close()
|
||||
_ = logger.Close()
|
||||
return nil, err
|
||||
}
|
||||
repo := repository.NewSQLDomainRepository(db.DB)
|
||||
server := httpapi.New(httpapi.Dependencies{Config: cfg, Logger: logger, Repository: repo})
|
||||
return &App{Config: cfg, Logger: logger, Database: db, Repository: repo, HTTP: server}, nil
|
||||
}
|
||||
|
||||
func (a *App) Close() error {
|
||||
if a == nil {
|
||||
return nil
|
||||
}
|
||||
var first error
|
||||
if a.HTTP != nil {
|
||||
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
|
||||
if err := a.HTTP.Shutdown(ctx); err != nil && first == nil {
|
||||
first = err
|
||||
}
|
||||
cancel()
|
||||
}
|
||||
if a.Database != nil {
|
||||
if err := a.Database.Close(); err != nil && first == nil {
|
||||
first = err
|
||||
}
|
||||
}
|
||||
if a.Logger != nil {
|
||||
if err := a.Logger.Close(); err != nil && first == nil {
|
||||
first = err
|
||||
}
|
||||
}
|
||||
return first
|
||||
}
|
||||
|
||||
func makeDirectory(path string) error {
|
||||
return osMkdirAll(path)
|
||||
}
|
||||
@@ -0,0 +1,7 @@
|
||||
package app
|
||||
|
||||
import "os"
|
||||
|
||||
var osMkdirAll = func(path string) error {
|
||||
return os.MkdirAll(path, 0o750)
|
||||
}
|
||||
@@ -0,0 +1,3 @@
|
||||
package buildinfo
|
||||
|
||||
const Version = "0.1.0"
|
||||
@@ -0,0 +1,234 @@
|
||||
package cli
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"fmt"
|
||||
"net/http"
|
||||
"os"
|
||||
"os/signal"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
"syscall"
|
||||
|
||||
"github.com/spf13/cobra"
|
||||
|
||||
"git.pcux.cn/xuans/Scert/backend/internal/app"
|
||||
"git.pcux.cn/xuans/Scert/backend/internal/buildinfo"
|
||||
"git.pcux.cn/xuans/Scert/backend/internal/config"
|
||||
"git.pcux.cn/xuans/Scert/backend/internal/domain"
|
||||
)
|
||||
|
||||
const version = buildinfo.Version
|
||||
|
||||
var (
|
||||
configPath string
|
||||
baseDir string
|
||||
)
|
||||
|
||||
const helpTemplate = `{{with (or .Long .Short)}}{{. | trimTrailingWhitespaces}}{{end}}
|
||||
|
||||
用法:
|
||||
{{.UseLine}}{{if .HasAvailableSubCommands}}
|
||||
|
||||
可用命令:
|
||||
{{range .Commands}}{{if (or .IsAvailableCommand (eq .Name "help"))}} {{rpad .Name .NamePadding }} {{.Short}}{{"\n"}}{{end}}{{end}}{{end}}{{if .HasAvailableLocalFlags}}
|
||||
|
||||
参数:
|
||||
{{.LocalFlags.FlagUsages | trimTrailingWhitespaces}}{{end}}{{if .HasAvailableInheritedFlags}}
|
||||
|
||||
全局参数:
|
||||
{{.InheritedFlags.FlagUsages | trimTrailingWhitespaces}}{{end}}{{if .HasHelpSubCommands}}
|
||||
|
||||
其他帮助:
|
||||
{{.CommandPath}} help [命令]{{end}}
|
||||
`
|
||||
|
||||
func Execute() {
|
||||
if err := newRootCommand().Execute(); err != nil {
|
||||
fmt.Fprintln(os.Stderr, "错误:", err)
|
||||
os.Exit(1)
|
||||
}
|
||||
}
|
||||
|
||||
func newRootCommand() *cobra.Command {
|
||||
root := &cobra.Command{Use: "scert", Short: "SSL 证书管理服务", SilenceUsage: true}
|
||||
root.CompletionOptions.DisableDefaultCmd = true
|
||||
root.SetHelpCommand(newHelpCommand())
|
||||
root.SetHelpTemplate(helpTemplate)
|
||||
root.PersistentFlags().StringVar(&configPath, "config", "", "配置文件路径")
|
||||
root.PersistentFlags().StringVar(&baseDir, "base-dir", "", "Windows 默认安装根目录")
|
||||
root.AddCommand(
|
||||
&cobra.Command{Use: "version", Short: "显示版本信息", Run: func(cmd *cobra.Command, args []string) { cmd.Printf("Scert %s\n", version) }},
|
||||
newInitCommand(), newStatusCommand(), newServeCommand(), newDomainCommand(),
|
||||
)
|
||||
localizeHelpFlags(root)
|
||||
return root
|
||||
}
|
||||
|
||||
func newHelpCommand() *cobra.Command {
|
||||
return &cobra.Command{
|
||||
Use: "help [命令]",
|
||||
Short: "显示帮助信息",
|
||||
RunE: func(cmd *cobra.Command, args []string) error {
|
||||
if len(args) == 0 {
|
||||
return cmd.Root().Help()
|
||||
}
|
||||
target, remaining, err := cmd.Root().Find(args)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if len(remaining) > 0 {
|
||||
return fmt.Errorf("未知命令:%s", strings.Join(remaining, " "))
|
||||
}
|
||||
return target.Help()
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
func localizeHelpFlags(command *cobra.Command) {
|
||||
command.DisableFlagsInUseLine = true
|
||||
command.InitDefaultHelpFlag()
|
||||
if flag := command.Flags().Lookup("help"); flag != nil {
|
||||
flag.Usage = "显示帮助信息"
|
||||
}
|
||||
for _, child := range command.Commands() {
|
||||
localizeHelpFlags(child)
|
||||
}
|
||||
}
|
||||
|
||||
func newInitCommand() *cobra.Command {
|
||||
return &cobra.Command{Use: "init", Short: "生成初始配置", RunE: func(cmd *cobra.Command, args []string) error {
|
||||
path := resolveConfigPath()
|
||||
if _, err := os.Stat(path); err == nil {
|
||||
return fmt.Errorf("配置文件已存在:%s", path)
|
||||
} else if !errors.Is(err, os.ErrNotExist) {
|
||||
return err
|
||||
}
|
||||
cfg := config.Default(baseDir)
|
||||
if err := cfg.Save(path); err != nil {
|
||||
return err
|
||||
}
|
||||
fmt.Printf("初始配置已生成:%s\n", path)
|
||||
fmt.Println("当前默认使用 ACME Staging 环境,完成 DNS 配置后再切换 Production。")
|
||||
return nil
|
||||
}}
|
||||
}
|
||||
|
||||
func newStatusCommand() *cobra.Command {
|
||||
return &cobra.Command{Use: "status", Short: "查看服务状态", RunE: func(cmd *cobra.Command, args []string) error {
|
||||
cfg, err := loadConfig()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
return printJSON(cmd, commandStatus(cfg))
|
||||
}}
|
||||
}
|
||||
|
||||
func commandStatus(cfg config.Config) map[string]any {
|
||||
return map[string]any{"service": "scert", "version": buildinfo.Version, "config_version": cfg.Version, "setup_ready": cfg.SetupReady, "https_mode": cfg.Server.HTTPSMode, "database_driver": cfg.Database.Driver}
|
||||
}
|
||||
|
||||
func newServeCommand() *cobra.Command {
|
||||
return &cobra.Command{Use: "serve", Short: "启动 Web 服务", RunE: func(cmd *cobra.Command, args []string) error {
|
||||
cfg, err := loadConfig()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
service, err := app.New(cmd.Context(), cfg)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
defer service.Close()
|
||||
ctx, stop := signal.NotifyContext(cmd.Context(), os.Interrupt, syscall.SIGTERM)
|
||||
defer stop()
|
||||
errCh := make(chan error, 1)
|
||||
go func() { errCh <- service.HTTP.ListenAndServe() }()
|
||||
select {
|
||||
case <-ctx.Done():
|
||||
return nil
|
||||
case err := <-errCh:
|
||||
if errors.Is(err, http.ErrServerClosed) {
|
||||
return nil
|
||||
}
|
||||
return err
|
||||
}
|
||||
}}
|
||||
}
|
||||
|
||||
func newDomainCommand() *cobra.Command {
|
||||
command := &cobra.Command{Use: "domain", Short: "管理托管域名"}
|
||||
command.AddCommand(newDomainListCommand(), newDomainAddCommand())
|
||||
return command
|
||||
}
|
||||
|
||||
func newDomainListCommand() *cobra.Command {
|
||||
return &cobra.Command{Use: "list", Short: "查看域名列表", RunE: func(cmd *cobra.Command, args []string) error {
|
||||
cfg, err := loadConfig()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
service, err := app.New(cmd.Context(), cfg)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
defer service.Close()
|
||||
items, err := service.Repository.List(cmd.Context())
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
return printJSON(cmd, items)
|
||||
}}
|
||||
}
|
||||
|
||||
func newDomainAddCommand() *cobra.Command {
|
||||
var name, certificateType string
|
||||
var sans []string
|
||||
command := &cobra.Command{Use: "add", Short: "添加托管域名", RunE: func(cmd *cobra.Command, args []string) error {
|
||||
cfg, err := loadConfig()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
service, err := app.New(cmd.Context(), cfg)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
defer service.Close()
|
||||
item, err := domain.NewDomain(name, domain.CertificateType(certificateType), sans)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if err := service.Repository.Create(cmd.Context(), item); err != nil {
|
||||
return err
|
||||
}
|
||||
fmt.Printf("域名已添加:%s\n", item.Name)
|
||||
return nil
|
||||
}}
|
||||
command.Flags().StringVar(&name, "name", "", "域名")
|
||||
command.Flags().StringVar(&certificateType, "type", string(domain.CertificateSingle), "证书类型:single、wildcard、san")
|
||||
command.Flags().StringSliceVar(&sans, "sans", nil, "SAN 域名列表")
|
||||
_ = command.MarkFlagRequired("name")
|
||||
return command
|
||||
}
|
||||
|
||||
func printJSON(cmd *cobra.Command, value any) error {
|
||||
data, err := json.MarshalIndent(value, "", " ")
|
||||
if err != nil {
|
||||
return fmt.Errorf("编码 JSON 失败:%w", err)
|
||||
}
|
||||
_, err = fmt.Fprintln(cmd.OutOrStdout(), string(data))
|
||||
return err
|
||||
}
|
||||
|
||||
func loadConfig() (config.Config, error) {
|
||||
path := resolveConfigPath()
|
||||
return config.Load(path)
|
||||
}
|
||||
|
||||
func resolveConfigPath() string {
|
||||
if configPath != "" {
|
||||
return configPath
|
||||
}
|
||||
paths := config.DefaultPaths(baseDir)
|
||||
return filepath.Join(paths.Config, "scert.json")
|
||||
}
|
||||
@@ -0,0 +1,60 @@
|
||||
package cli
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"strings"
|
||||
"testing"
|
||||
|
||||
"git.pcux.cn/xuans/Scert/backend/internal/buildinfo"
|
||||
"git.pcux.cn/xuans/Scert/backend/internal/config"
|
||||
)
|
||||
|
||||
func TestHelpIsLocalizedAndHasNoDuplicateCommands(t *testing.T) {
|
||||
configPath = ""
|
||||
baseDir = ""
|
||||
root := newRootCommand()
|
||||
var output bytes.Buffer
|
||||
root.SetOut(&output)
|
||||
root.SetErr(&output)
|
||||
root.SetArgs([]string{"help"})
|
||||
if err := root.Execute(); err != nil {
|
||||
t.Fatalf("执行帮助命令失败:%v", err)
|
||||
}
|
||||
text := output.String()
|
||||
for _, expected := range []string{"用法:", "可用命令:", "参数:"} {
|
||||
if !strings.Contains(text, expected) {
|
||||
t.Fatalf("帮助缺少中文标题 %q:%s", expected, text)
|
||||
}
|
||||
}
|
||||
for _, unexpected := range []string{"Available Commands:", "Usage:", "Flags:", "completion"} {
|
||||
if strings.Contains(text, unexpected) {
|
||||
t.Fatalf("帮助仍包含未本地化或禁用内容 %q:%s", unexpected, text)
|
||||
}
|
||||
}
|
||||
if strings.Count(text, "\n help ") != 1 {
|
||||
t.Fatalf("help 命令数量不正确:%s", text)
|
||||
}
|
||||
}
|
||||
|
||||
func TestHelpSupportsSubcommand(t *testing.T) {
|
||||
root := newRootCommand()
|
||||
var output bytes.Buffer
|
||||
root.SetOut(&output)
|
||||
root.SetErr(&output)
|
||||
root.SetArgs([]string{"help", "domain"})
|
||||
if err := root.Execute(); err != nil {
|
||||
t.Fatalf("查看子命令帮助失败:%v", err)
|
||||
}
|
||||
text := output.String()
|
||||
if !strings.Contains(text, "管理托管域名") || !strings.Contains(text, "添加托管域名") {
|
||||
t.Fatalf("子命令帮助内容不正确:%s", text)
|
||||
}
|
||||
}
|
||||
|
||||
func TestCommandStatusUsesApplicationVersion(t *testing.T) {
|
||||
cfg := config.Default(t.TempDir())
|
||||
status := commandStatus(cfg)
|
||||
if status["version"] != buildinfo.Version || status["config_version"] != config.CurrentVersion {
|
||||
t.Fatalf("状态版本字段不正确:%+v", status)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,183 @@
|
||||
package config
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"runtime"
|
||||
"strings"
|
||||
)
|
||||
|
||||
const CurrentVersion = 1
|
||||
const ConfigFormat = "json"
|
||||
|
||||
type Config struct {
|
||||
Version int `json:"version"`
|
||||
SetupReady bool `json:"setup_ready"`
|
||||
Server ServerConfig `json:"server"`
|
||||
Database DatabaseConfig `json:"database"`
|
||||
Paths PathsConfig `json:"paths"`
|
||||
ACME ACMEConfig `json:"acme"`
|
||||
Notification NotificationConfig `json:"notification"`
|
||||
}
|
||||
|
||||
type ServerConfig struct {
|
||||
Host string `json:"host"`
|
||||
Port int `json:"port"`
|
||||
HTTPSMode string `json:"https_mode"`
|
||||
}
|
||||
|
||||
type DatabaseConfig struct {
|
||||
Driver string `json:"driver"`
|
||||
DSN string `json:"dsn"`
|
||||
MaxOpenConns int `json:"max_open_conns"`
|
||||
MaxIdleConns int `json:"max_idle_conns"`
|
||||
ConnMaxLifetimeMins int `json:"conn_max_lifetime_mins"`
|
||||
}
|
||||
|
||||
type PathsConfig struct {
|
||||
Install string `json:"install"`
|
||||
Certificate string `json:"certificate"`
|
||||
Config string `json:"config"`
|
||||
Data string `json:"data"`
|
||||
Log string `json:"log"`
|
||||
Backup string `json:"backup"`
|
||||
}
|
||||
|
||||
type ACMEConfig struct {
|
||||
CA string `json:"ca"`
|
||||
Environment string `json:"environment"`
|
||||
AccountEmail string `json:"account_email"`
|
||||
RenewalThresholdDays int `json:"renewal_threshold_days"`
|
||||
}
|
||||
|
||||
type NotificationConfig struct {
|
||||
HTTPEnabled bool `json:"http_enabled"`
|
||||
SMTPEnabled bool `json:"smtp_enabled"`
|
||||
TimeoutSecs int `json:"timeout_secs"`
|
||||
RetryCount int `json:"retry_count"`
|
||||
}
|
||||
|
||||
func Default(baseDir string) Config {
|
||||
paths := DefaultPaths(baseDir)
|
||||
return Config{
|
||||
Version: CurrentVersion,
|
||||
SetupReady: false,
|
||||
Server: ServerConfig{Host: "127.0.0.1", Port: 8080, HTTPSMode: "direct"},
|
||||
Database: DatabaseConfig{
|
||||
Driver: "sqlite", DSN: filepath.Join(paths.Data, "scert.db"),
|
||||
MaxOpenConns: 4, MaxIdleConns: 2, ConnMaxLifetimeMins: 30,
|
||||
},
|
||||
Paths: paths,
|
||||
ACME: ACMEConfig{CA: "letsencrypt", Environment: "staging", RenewalThresholdDays: 6},
|
||||
Notification: NotificationConfig{TimeoutSecs: 10, RetryCount: 3},
|
||||
}
|
||||
}
|
||||
|
||||
func DefaultPaths(baseDir string) PathsConfig {
|
||||
if runtime.GOOS == "linux" {
|
||||
return PathsConfig{
|
||||
Install: "/scert", Certificate: "/ssl", Config: "/scert/conf",
|
||||
Data: "/scert/data", Log: "/scert/log", Backup: "/scert/backups",
|
||||
}
|
||||
}
|
||||
if strings.TrimSpace(baseDir) == "" {
|
||||
baseDir = "."
|
||||
}
|
||||
install := filepath.Join(baseDir, "Scert")
|
||||
return PathsConfig{
|
||||
Install: install, Certificate: filepath.Join(install, "ssl"),
|
||||
Config: filepath.Join(install, "config"), Data: filepath.Join(install, "data"),
|
||||
Log: filepath.Join(install, "logs"), Backup: filepath.Join(install, "backups"),
|
||||
}
|
||||
}
|
||||
|
||||
func Load(path string) (Config, error) {
|
||||
data, err := os.ReadFile(path)
|
||||
if err != nil {
|
||||
return Config{}, fmt.Errorf("读取配置文件失败:%w", err)
|
||||
}
|
||||
var cfg Config
|
||||
if err := json.Unmarshal(data, &cfg); err != nil {
|
||||
return Config{}, fmt.Errorf("解析配置文件失败:%w", err)
|
||||
}
|
||||
if err := cfg.Validate(); err != nil {
|
||||
return Config{}, err
|
||||
}
|
||||
return cfg, nil
|
||||
}
|
||||
|
||||
func (c Config) Save(path string) error {
|
||||
if err := c.Validate(); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := os.MkdirAll(filepath.Dir(path), 0o700); err != nil {
|
||||
return fmt.Errorf("创建配置目录失败:%w", err)
|
||||
}
|
||||
data, err := json.MarshalIndent(c, "", " ")
|
||||
if err != nil {
|
||||
return fmt.Errorf("编码配置失败:%w", err)
|
||||
}
|
||||
data = append(data, '\n')
|
||||
tmpPath := path + ".tmp"
|
||||
if err := os.WriteFile(tmpPath, data, 0o600); err != nil {
|
||||
return fmt.Errorf("写入临时配置文件失败:%w", err)
|
||||
}
|
||||
if err := os.Rename(tmpPath, path); err != nil {
|
||||
_ = os.Remove(tmpPath)
|
||||
return fmt.Errorf("替换配置文件失败:%w", err)
|
||||
}
|
||||
if err := os.Chmod(path, 0o600); err != nil {
|
||||
return fmt.Errorf("设置配置文件权限失败:%w", err)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (c Config) Validate() error {
|
||||
if c.Version != CurrentVersion {
|
||||
return fmt.Errorf("配置版本不兼容:%d", c.Version)
|
||||
}
|
||||
if strings.TrimSpace(c.Server.Host) == "" {
|
||||
return fmt.Errorf("服务监听地址不能为空")
|
||||
}
|
||||
if c.Server.Port < 1 || c.Server.Port > 65535 {
|
||||
return fmt.Errorf("服务监听端口无效:%d", c.Server.Port)
|
||||
}
|
||||
if c.Server.HTTPSMode != "direct" && c.Server.HTTPSMode != "proxy" {
|
||||
return fmt.Errorf("HTTPS 模式无效:%s", c.Server.HTTPSMode)
|
||||
}
|
||||
if c.Database.Driver != "sqlite" && c.Database.Driver != "mysql" {
|
||||
return fmt.Errorf("数据库驱动无效:%s", c.Database.Driver)
|
||||
}
|
||||
if strings.TrimSpace(c.Database.DSN) == "" {
|
||||
return fmt.Errorf("数据库连接信息不能为空")
|
||||
}
|
||||
if c.Database.MaxOpenConns < 1 || c.Database.MaxIdleConns < 0 || c.Database.MaxIdleConns > c.Database.MaxOpenConns {
|
||||
return fmt.Errorf("数据库连接池配置无效")
|
||||
}
|
||||
if c.Database.ConnMaxLifetimeMins < 0 {
|
||||
return fmt.Errorf("数据库连接生命周期不能为负数")
|
||||
}
|
||||
for name, value := range map[string]string{
|
||||
"安装目录": c.Paths.Install, "证书目录": c.Paths.Certificate, "配置目录": c.Paths.Config,
|
||||
"数据目录": c.Paths.Data, "日志目录": c.Paths.Log, "备份目录": c.Paths.Backup,
|
||||
} {
|
||||
if strings.TrimSpace(value) == "" {
|
||||
return fmt.Errorf("%s不能为空", name)
|
||||
}
|
||||
}
|
||||
if c.ACME.CA != "letsencrypt" {
|
||||
return fmt.Errorf("当前仅支持 Let's Encrypt")
|
||||
}
|
||||
if c.ACME.Environment != "staging" && c.ACME.Environment != "production" {
|
||||
return fmt.Errorf("ACME 环境无效:%s", c.ACME.Environment)
|
||||
}
|
||||
if c.ACME.RenewalThresholdDays < 1 {
|
||||
return fmt.Errorf("续期阈值必须大于 0")
|
||||
}
|
||||
if c.Notification.TimeoutSecs < 1 || c.Notification.RetryCount < 0 {
|
||||
return fmt.Errorf("通知配置无效")
|
||||
}
|
||||
return nil
|
||||
}
|
||||
@@ -0,0 +1,44 @@
|
||||
package config
|
||||
|
||||
import (
|
||||
"path/filepath"
|
||||
"runtime"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestDefaultPaths(t *testing.T) {
|
||||
paths := DefaultPaths(t.TempDir())
|
||||
if runtime.GOOS == "linux" {
|
||||
if paths.Install != "/scert" || paths.Certificate != "/ssl" {
|
||||
t.Fatalf("Linux 默认路径不正确:%+v", paths)
|
||||
}
|
||||
return
|
||||
}
|
||||
if filepath.Base(paths.Install) != "Scert" || filepath.Base(paths.Certificate) != "ssl" {
|
||||
t.Fatalf("Windows 默认路径不正确:%+v", paths)
|
||||
}
|
||||
}
|
||||
|
||||
func TestSaveAndLoad(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
cfg := Default(dir)
|
||||
path := filepath.Join(dir, "config", "scert.json")
|
||||
if err := cfg.Save(path); err != nil {
|
||||
t.Fatalf("保存配置失败:%v", err)
|
||||
}
|
||||
loaded, err := Load(path)
|
||||
if err != nil {
|
||||
t.Fatalf("读取配置失败:%v", err)
|
||||
}
|
||||
if loaded.Version != cfg.Version || loaded.Database.Driver != "sqlite" {
|
||||
t.Fatalf("读取配置内容不一致:%+v", loaded)
|
||||
}
|
||||
}
|
||||
|
||||
func TestValidateRejectsInvalidPort(t *testing.T) {
|
||||
cfg := Default(t.TempDir())
|
||||
cfg.Server.Port = 70000
|
||||
if err := cfg.Validate(); err == nil {
|
||||
t.Fatal("无效端口未被拒绝")
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,45 @@
|
||||
package config
|
||||
|
||||
import (
|
||||
"os"
|
||||
"path/filepath"
|
||||
"runtime"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestValidateRejectsIncompatibleVersion(t *testing.T) {
|
||||
cfg := Default(t.TempDir())
|
||||
cfg.Version = CurrentVersion + 1
|
||||
if err := cfg.Validate(); err == nil {
|
||||
t.Fatal("不兼容配置版本未被拒绝")
|
||||
}
|
||||
}
|
||||
|
||||
func TestSaveCanReplaceExistingConfig(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
path := filepath.Join(dir, "config", "scert.json")
|
||||
cfg := Default(dir)
|
||||
if err := cfg.Save(path); err != nil {
|
||||
t.Fatalf("首次保存配置失败:%v", err)
|
||||
}
|
||||
cfg.Server.Port = 9443
|
||||
if err := cfg.Save(path); err != nil {
|
||||
t.Fatalf("覆盖保存配置失败:%v", err)
|
||||
}
|
||||
loaded, err := Load(path)
|
||||
if err != nil {
|
||||
t.Fatalf("读取覆盖后的配置失败:%v", err)
|
||||
}
|
||||
if loaded.Server.Port != 9443 {
|
||||
t.Fatalf("覆盖后的配置内容不正确:%d", loaded.Server.Port)
|
||||
}
|
||||
if runtime.GOOS != "windows" {
|
||||
info, err := os.Stat(path)
|
||||
if err != nil {
|
||||
t.Fatalf("读取配置文件权限失败:%v", err)
|
||||
}
|
||||
if info.Mode().Perm() != 0o600 {
|
||||
t.Fatalf("配置文件权限不正确:%o", info.Mode().Perm())
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,90 @@
|
||||
package database
|
||||
|
||||
import (
|
||||
"context"
|
||||
"database/sql"
|
||||
"fmt"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"github.com/go-sql-driver/mysql"
|
||||
_ "modernc.org/sqlite"
|
||||
|
||||
"git.pcux.cn/xuans/Scert/backend/internal/config"
|
||||
)
|
||||
|
||||
type Database struct {
|
||||
DB *sql.DB
|
||||
}
|
||||
|
||||
func Open(ctx context.Context, cfg config.DatabaseConfig) (*Database, error) {
|
||||
if cfg.Driver != "sqlite" && cfg.Driver != "mysql" {
|
||||
return nil, fmt.Errorf("数据库驱动无效:%s", cfg.Driver)
|
||||
}
|
||||
dsn := cfg.DSN
|
||||
if cfg.Driver == "mysql" {
|
||||
var err error
|
||||
dsn, err = normalizeMySQLDSN(dsn)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
}
|
||||
if cfg.Driver == "sqlite" {
|
||||
if cfg.DSN != ":memory:" && len(cfg.DSN) > 0 && cfg.DSN != "file::memory:?cache=shared" {
|
||||
if err := ensureSQLiteDir(cfg.DSN); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
}
|
||||
}
|
||||
db, err := sql.Open(cfg.Driver, dsn)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("打开数据库失败:%w", err)
|
||||
}
|
||||
db.SetMaxOpenConns(cfg.MaxOpenConns)
|
||||
db.SetMaxIdleConns(cfg.MaxIdleConns)
|
||||
db.SetConnMaxLifetime(time.Duration(cfg.ConnMaxLifetimeMins) * time.Minute)
|
||||
pingCtx, cancel := context.WithTimeout(ctx, 10*time.Second)
|
||||
defer cancel()
|
||||
if err := db.PingContext(pingCtx); err != nil {
|
||||
_ = db.Close()
|
||||
return nil, fmt.Errorf("连接数据库失败:%w", err)
|
||||
}
|
||||
return &Database{DB: db}, nil
|
||||
}
|
||||
|
||||
func normalizeMySQLDSN(dsn string) (string, error) {
|
||||
cfg, err := mysql.ParseDSN(dsn)
|
||||
if err != nil {
|
||||
return "", fmt.Errorf("解析 MySQL 连接信息失败:%w", err)
|
||||
}
|
||||
cfg.ParseTime = true
|
||||
cfg.Loc = time.UTC
|
||||
return cfg.FormatDSN(), nil
|
||||
}
|
||||
|
||||
func ensureSQLiteDir(dsn string) error {
|
||||
path := dsn
|
||||
if strings.HasPrefix(path, "file:") {
|
||||
path = strings.TrimPrefix(strings.SplitN(path, "?", 2)[0], "file:")
|
||||
}
|
||||
return osMkdirAll(filepath.Dir(path))
|
||||
}
|
||||
|
||||
var osMkdirAll = func(path string) error {
|
||||
if path == "." || path == "" {
|
||||
return nil
|
||||
}
|
||||
return mkdirAll(path)
|
||||
}
|
||||
|
||||
var mkdirAll = func(path string) error {
|
||||
return makeDirectory(path)
|
||||
}
|
||||
|
||||
func (d *Database) Close() error {
|
||||
if d == nil || d.DB == nil {
|
||||
return nil
|
||||
}
|
||||
return d.DB.Close()
|
||||
}
|
||||
@@ -0,0 +1,30 @@
|
||||
package database
|
||||
|
||||
import (
|
||||
"context"
|
||||
"path/filepath"
|
||||
"testing"
|
||||
|
||||
"git.pcux.cn/xuans/Scert/backend/internal/config"
|
||||
)
|
||||
|
||||
func TestOpenAndMigrateSQLite(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
cfg := config.Default(dir)
|
||||
cfg.Database.DSN = filepath.Join(dir, "data", "test.db")
|
||||
db, err := Open(context.Background(), cfg.Database)
|
||||
if err != nil {
|
||||
t.Fatalf("打开 SQLite 失败:%v", err)
|
||||
}
|
||||
defer db.Close()
|
||||
if err := Migrate(context.Background(), db.DB, "sqlite"); err != nil {
|
||||
t.Fatalf("SQLite 迁移失败:%v", err)
|
||||
}
|
||||
var count int
|
||||
if err := db.DB.QueryRow("SELECT COUNT(*) FROM schema_migrations").Scan(&count); err != nil {
|
||||
t.Fatalf("读取迁移版本失败:%v", err)
|
||||
}
|
||||
if count != 1 {
|
||||
t.Fatalf("迁移版本数量错误:%d", count)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,7 @@
|
||||
package database
|
||||
|
||||
import "os"
|
||||
|
||||
func makeDirectory(path string) error {
|
||||
return os.MkdirAll(path, 0o750)
|
||||
}
|
||||
@@ -0,0 +1,97 @@
|
||||
package database
|
||||
|
||||
import (
|
||||
"context"
|
||||
"database/sql"
|
||||
"embed"
|
||||
"fmt"
|
||||
"strings"
|
||||
)
|
||||
|
||||
//go:embed migrations/sqlite/0001_initial.sql migrations/mysql/0001_initial.sql
|
||||
var migrationFiles embed.FS
|
||||
|
||||
func Migrate(ctx context.Context, db *sql.DB, driver string) error {
|
||||
if db == nil {
|
||||
return fmt.Errorf("数据库连接不能为空")
|
||||
}
|
||||
if driver != "sqlite" && driver != "mysql" {
|
||||
return fmt.Errorf("数据库驱动无效:%s", driver)
|
||||
}
|
||||
if _, err := db.ExecContext(ctx, migrationTableSQL(driver)); err != nil {
|
||||
return fmt.Errorf("创建迁移表失败:%w", err)
|
||||
}
|
||||
var version int
|
||||
err := db.QueryRowContext(ctx, "SELECT version FROM schema_migrations ORDER BY version DESC LIMIT 1").Scan(&version)
|
||||
if err != nil && err != sql.ErrNoRows {
|
||||
return fmt.Errorf("读取迁移版本失败:%w", err)
|
||||
}
|
||||
if err == sql.ErrNoRows {
|
||||
version = 0
|
||||
}
|
||||
if version >= 1 {
|
||||
return nil
|
||||
}
|
||||
path := "migrations/sqlite/0001_initial.sql"
|
||||
if driver == "mysql" {
|
||||
path = "migrations/mysql/0001_initial.sql"
|
||||
}
|
||||
content, err := migrationFiles.ReadFile(path)
|
||||
if err != nil {
|
||||
return fmt.Errorf("读取迁移文件失败:%w", err)
|
||||
}
|
||||
statements := migrationStatements(content)
|
||||
if driver == "mysql" {
|
||||
for _, statement := range statements {
|
||||
if _, err := db.ExecContext(ctx, statement); err != nil {
|
||||
return fmt.Errorf("执行数据库迁移失败:%w", err)
|
||||
}
|
||||
}
|
||||
if _, err := db.ExecContext(ctx, "INSERT INTO schema_migrations (version) VALUES (1)"); err != nil {
|
||||
return fmt.Errorf("记录迁移版本失败:%w", err)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
tx, err := db.BeginTx(ctx, nil)
|
||||
if err != nil {
|
||||
return fmt.Errorf("开始迁移事务失败:%w", err)
|
||||
}
|
||||
for _, statement := range statements {
|
||||
if _, err := tx.ExecContext(ctx, statement); err != nil {
|
||||
_ = tx.Rollback()
|
||||
return fmt.Errorf("执行数据库迁移失败:%w", err)
|
||||
}
|
||||
}
|
||||
if _, err := tx.ExecContext(ctx, "INSERT INTO schema_migrations (version) VALUES (1)"); err != nil {
|
||||
_ = tx.Rollback()
|
||||
return fmt.Errorf("记录迁移版本失败:%w", err)
|
||||
}
|
||||
if err := tx.Commit(); err != nil {
|
||||
return fmt.Errorf("提交数据库迁移失败:%w", err)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func migrationStatements(content []byte) []string {
|
||||
statements := make([]string, 0)
|
||||
for _, statement := range strings.Split(string(content), ";") {
|
||||
statement = strings.TrimSpace(statement)
|
||||
if statement != "" {
|
||||
statements = append(statements, statement)
|
||||
}
|
||||
}
|
||||
return statements
|
||||
}
|
||||
|
||||
func migrationTableSQL(driver string) string {
|
||||
if driver == "mysql" {
|
||||
return `CREATE TABLE IF NOT EXISTS schema_migrations (
|
||||
version INT NOT NULL PRIMARY KEY,
|
||||
applied_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
|
||||
)`
|
||||
}
|
||||
return `CREATE TABLE IF NOT EXISTS schema_migrations (
|
||||
version INTEGER NOT NULL PRIMARY KEY,
|
||||
applied_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
|
||||
)`
|
||||
}
|
||||
@@ -0,0 +1,39 @@
|
||||
CREATE TABLE IF NOT EXISTS settings (
|
||||
`key` VARCHAR(128) NOT NULL PRIMARY KEY,
|
||||
`value` TEXT NOT NULL,
|
||||
updated_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
|
||||
);
|
||||
|
||||
CREATE TABLE IF NOT EXISTS domains (
|
||||
id VARCHAR(36) NOT NULL PRIMARY KEY,
|
||||
name VARCHAR(253) NOT NULL UNIQUE,
|
||||
certificate_type VARCHAR(32) NOT NULL,
|
||||
sans_json TEXT NOT NULL,
|
||||
status VARCHAR(32) NOT NULL,
|
||||
expires_at DATETIME NULL,
|
||||
created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
|
||||
updated_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
|
||||
);
|
||||
|
||||
CREATE TABLE IF NOT EXISTS tasks (
|
||||
id VARCHAR(36) NOT NULL PRIMARY KEY,
|
||||
domain_id VARCHAR(36) NOT NULL,
|
||||
task_type VARCHAR(32) NOT NULL,
|
||||
status VARCHAR(32) NOT NULL,
|
||||
message TEXT NOT NULL,
|
||||
started_at DATETIME NULL,
|
||||
finished_at DATETIME NULL,
|
||||
created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
|
||||
INDEX idx_tasks_domain_id (domain_id)
|
||||
);
|
||||
|
||||
CREATE TABLE IF NOT EXISTS audit_logs (
|
||||
id BIGINT NOT NULL AUTO_INCREMENT PRIMARY KEY,
|
||||
action VARCHAR(64) NOT NULL,
|
||||
resource_type VARCHAR(64) NOT NULL,
|
||||
resource_id VARCHAR(36) NOT NULL,
|
||||
status VARCHAR(32) NOT NULL,
|
||||
message TEXT NOT NULL,
|
||||
created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
|
||||
INDEX idx_audit_logs_created_at (created_at)
|
||||
);
|
||||
@@ -0,0 +1,37 @@
|
||||
CREATE TABLE IF NOT EXISTS settings (
|
||||
key TEXT NOT NULL PRIMARY KEY,
|
||||
value TEXT NOT NULL,
|
||||
updated_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
|
||||
);
|
||||
|
||||
CREATE TABLE IF NOT EXISTS domains (
|
||||
id TEXT NOT NULL PRIMARY KEY,
|
||||
name TEXT NOT NULL UNIQUE,
|
||||
certificate_type TEXT NOT NULL,
|
||||
sans_json TEXT NOT NULL,
|
||||
status TEXT NOT NULL,
|
||||
expires_at DATETIME NULL,
|
||||
created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
|
||||
updated_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
|
||||
);
|
||||
|
||||
CREATE TABLE IF NOT EXISTS tasks (
|
||||
id TEXT NOT NULL PRIMARY KEY,
|
||||
domain_id TEXT NOT NULL,
|
||||
task_type TEXT NOT NULL,
|
||||
status TEXT NOT NULL,
|
||||
message TEXT NOT NULL,
|
||||
started_at DATETIME NULL,
|
||||
finished_at DATETIME NULL,
|
||||
created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
|
||||
);
|
||||
|
||||
CREATE TABLE IF NOT EXISTS audit_logs (
|
||||
id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
|
||||
action TEXT NOT NULL,
|
||||
resource_type TEXT NOT NULL,
|
||||
resource_id TEXT NOT NULL,
|
||||
status TEXT NOT NULL,
|
||||
message TEXT NOT NULL,
|
||||
created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
|
||||
);
|
||||
@@ -0,0 +1,68 @@
|
||||
package database
|
||||
|
||||
import (
|
||||
"context"
|
||||
"path/filepath"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"github.com/go-sql-driver/mysql"
|
||||
|
||||
"git.pcux.cn/xuans/Scert/backend/internal/config"
|
||||
)
|
||||
|
||||
func TestOpenRejectsUnknownDriver(t *testing.T) {
|
||||
cfg := config.Default(t.TempDir()).Database
|
||||
cfg.Driver = "postgres"
|
||||
cfg.DSN = "unused"
|
||||
if _, err := Open(context.Background(), cfg); err == nil {
|
||||
t.Fatal("未知数据库驱动未被拒绝")
|
||||
}
|
||||
}
|
||||
|
||||
func TestNormalizeMySQLDSNEnablesTimeParsing(t *testing.T) {
|
||||
dsn, err := normalizeMySQLDSN("user:password@tcp(127.0.0.1:3306)/scert?charset=utf8mb4")
|
||||
if err != nil {
|
||||
t.Fatalf("规范化 MySQL DSN 失败:%v", err)
|
||||
}
|
||||
parsed, err := mysql.ParseDSN(dsn)
|
||||
if err != nil {
|
||||
t.Fatalf("解析规范化后的 MySQL DSN 失败:%v", err)
|
||||
}
|
||||
if !parsed.ParseTime || parsed.Loc != time.UTC {
|
||||
t.Fatal("MySQL DSN 未启用时间解析或未使用 UTC")
|
||||
}
|
||||
}
|
||||
|
||||
func TestSQLiteMigrationIsIdempotentAndCreatesBaseTables(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
cfg := config.Default(dir).Database
|
||||
cfg.DSN = filepath.Join(dir, "data", "review.db")
|
||||
db, err := Open(context.Background(), cfg)
|
||||
if err != nil {
|
||||
t.Fatalf("打开 SQLite 失败:%v", err)
|
||||
}
|
||||
defer db.Close()
|
||||
for i := 0; i < 2; i++ {
|
||||
if err := Migrate(context.Background(), db.DB, "sqlite"); err != nil {
|
||||
t.Fatalf("第 %d 次迁移失败:%v", i+1, err)
|
||||
}
|
||||
}
|
||||
var versions int
|
||||
if err := db.DB.QueryRow("SELECT COUNT(*) FROM schema_migrations").Scan(&versions); err != nil {
|
||||
t.Fatalf("读取迁移版本失败:%v", err)
|
||||
}
|
||||
if versions != 1 {
|
||||
t.Fatalf("重复迁移写入了多条版本记录:%d", versions)
|
||||
}
|
||||
var tables int
|
||||
if err := db.DB.QueryRow(`SELECT COUNT(*) FROM sqlite_master WHERE type = 'table' AND name IN ('settings', 'domains', 'tasks', 'audit_logs')`).Scan(&tables); err != nil {
|
||||
t.Fatalf("检查基础数据表失败:%v", err)
|
||||
}
|
||||
if tables != 4 {
|
||||
t.Fatalf("基础数据表数量不正确:%d", tables)
|
||||
}
|
||||
if err := Migrate(context.Background(), db.DB, "postgres"); err == nil {
|
||||
t.Fatal("未知迁移驱动未被拒绝")
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,99 @@
|
||||
package domain
|
||||
|
||||
import (
|
||||
"crypto/rand"
|
||||
"fmt"
|
||||
"regexp"
|
||||
"strings"
|
||||
"time"
|
||||
)
|
||||
|
||||
var domainPattern = regexp.MustCompile(`^(?i)([a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)+[a-z]{2,63}$`)
|
||||
|
||||
type CertificateType string
|
||||
|
||||
const (
|
||||
CertificateSingle CertificateType = "single"
|
||||
CertificateWildcard CertificateType = "wildcard"
|
||||
CertificateSAN CertificateType = "san"
|
||||
)
|
||||
|
||||
type Domain struct {
|
||||
ID string `json:"id"`
|
||||
Name string `json:"name"`
|
||||
CertificateType CertificateType `json:"certificate_type"`
|
||||
SANs []string `json:"sans"`
|
||||
Status string `json:"status"`
|
||||
ExpiresAt *time.Time `json:"expires_at,omitempty"`
|
||||
CreatedAt time.Time `json:"created_at"`
|
||||
UpdatedAt time.Time `json:"updated_at"`
|
||||
}
|
||||
|
||||
func NewDomain(name string, certificateType CertificateType, sans []string) (Domain, error) {
|
||||
name = strings.ToLower(strings.TrimSpace(name))
|
||||
if !IsValidName(name) {
|
||||
return Domain{}, fmt.Errorf("域名格式无效:%s", name)
|
||||
}
|
||||
if certificateType != CertificateSingle && certificateType != CertificateWildcard && certificateType != CertificateSAN {
|
||||
return Domain{}, fmt.Errorf("证书类型无效:%s", certificateType)
|
||||
}
|
||||
cleanSANs := normalizeSANs(sans)
|
||||
if certificateType == CertificateSAN {
|
||||
cleanSANs = normalizeSANs(append([]string{name}, cleanSANs...))
|
||||
}
|
||||
if certificateType == CertificateSAN && len(cleanSANs) < 2 {
|
||||
return Domain{}, fmt.Errorf("SAN 证书至少需要两个域名")
|
||||
}
|
||||
for _, san := range cleanSANs {
|
||||
if !IsValidName(san) {
|
||||
_, err := NewDomain(san, CertificateSingle, nil)
|
||||
return Domain{}, err
|
||||
}
|
||||
}
|
||||
if certificateType != CertificateSAN {
|
||||
cleanSANs = []string{name}
|
||||
}
|
||||
if certificateType == CertificateWildcard && !strings.HasPrefix(name, "*.") {
|
||||
return Domain{}, fmt.Errorf("泛域名必须以 *. 开头")
|
||||
}
|
||||
if certificateType != CertificateWildcard && strings.HasPrefix(name, "*.") {
|
||||
return Domain{}, fmt.Errorf("只有泛域名证书类型允许使用 *. 域名")
|
||||
}
|
||||
now := time.Now().UTC()
|
||||
return Domain{ID: NewID(), Name: name, CertificateType: certificateType, SANs: cleanSANs, Status: "pending", CreatedAt: now, UpdatedAt: now}, nil
|
||||
}
|
||||
|
||||
func IsValidName(name string) bool {
|
||||
name = strings.TrimSpace(strings.ToLower(name))
|
||||
if strings.HasPrefix(name, "*.") {
|
||||
name = strings.TrimPrefix(name, "*.")
|
||||
}
|
||||
return domainPattern.MatchString(name)
|
||||
}
|
||||
|
||||
func normalizeSANs(sans []string) []string {
|
||||
seen := make(map[string]struct{}, len(sans))
|
||||
result := make([]string, 0, len(sans))
|
||||
for _, item := range sans {
|
||||
item = strings.ToLower(strings.TrimSpace(item))
|
||||
if item == "" {
|
||||
continue
|
||||
}
|
||||
if _, ok := seen[item]; ok {
|
||||
continue
|
||||
}
|
||||
seen[item] = struct{}{}
|
||||
result = append(result, item)
|
||||
}
|
||||
return result
|
||||
}
|
||||
|
||||
func NewID() string {
|
||||
var b [16]byte
|
||||
if _, err := rand.Read(b[:]); err != nil {
|
||||
return fmt.Sprintf("%d", time.Now().UnixNano())
|
||||
}
|
||||
b[6] = (b[6] & 0x0f) | 0x40
|
||||
b[8] = (b[8] & 0x3f) | 0x80
|
||||
return fmt.Sprintf("%08x-%04x-%04x-%04x-%012x", b[0:4], b[4:6], b[6:8], b[8:10], b[10:16])
|
||||
}
|
||||
@@ -0,0 +1,57 @@
|
||||
package domain
|
||||
|
||||
import "testing"
|
||||
|
||||
func TestNewDomainTypes(t *testing.T) {
|
||||
tests := []struct {
|
||||
name string
|
||||
domainName string
|
||||
certificateType CertificateType
|
||||
wantError bool
|
||||
}{
|
||||
{name: "单域名", domainName: "Example.COM", certificateType: CertificateSingle},
|
||||
{name: "泛域名", domainName: "*.example.com", certificateType: CertificateWildcard},
|
||||
{name: "泛域名缺少前缀", domainName: "example.com", certificateType: CertificateWildcard, wantError: true},
|
||||
{name: "单域名使用泛域名", domainName: "*.example.com", certificateType: CertificateSingle, wantError: true},
|
||||
{name: "非法证书类型", domainName: "example.com", certificateType: CertificateType("invalid"), wantError: true},
|
||||
}
|
||||
for _, item := range tests {
|
||||
t.Run(item.name, func(t *testing.T) {
|
||||
result, err := NewDomain(item.domainName, item.certificateType, nil)
|
||||
if item.wantError {
|
||||
if err == nil {
|
||||
t.Fatal("预期返回错误,实际未返回")
|
||||
}
|
||||
return
|
||||
}
|
||||
if err != nil {
|
||||
t.Fatalf("创建域名失败:%v", err)
|
||||
}
|
||||
if result.Name == "" || len(result.SANs) != 1 || result.SANs[0] != result.Name {
|
||||
t.Fatalf("域名规范化结果不正确:%+v", result)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestNewDomainSANIncludesPrimaryAndDeduplicates(t *testing.T) {
|
||||
result, err := NewDomain("Example.com", CertificateSAN, []string{"www.example.com", "EXAMPLE.COM", "www.example.com"})
|
||||
if err != nil {
|
||||
t.Fatalf("创建 SAN 域名失败:%v", err)
|
||||
}
|
||||
if len(result.SANs) != 2 {
|
||||
t.Fatalf("SAN 去重结果不正确:%v", result.SANs)
|
||||
}
|
||||
if result.SANs[0] != "example.com" || result.SANs[1] != "www.example.com" {
|
||||
t.Fatalf("SAN 未自动包含主域名或顺序异常:%v", result.SANs)
|
||||
}
|
||||
}
|
||||
|
||||
func TestNewDomainSANValidation(t *testing.T) {
|
||||
if _, err := NewDomain("example.com", CertificateSAN, []string{"example.com"}); err == nil {
|
||||
t.Fatal("仅包含主域名的 SAN 配置未被拒绝")
|
||||
}
|
||||
if _, err := NewDomain("example.com", CertificateSAN, []string{"bad_domain"}); err == nil {
|
||||
t.Fatal("非法 SAN 域名未被拒绝")
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,104 @@
|
||||
package httpapi
|
||||
|
||||
import (
|
||||
"context"
|
||||
"database/sql"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"strings"
|
||||
"testing"
|
||||
|
||||
"git.pcux.cn/xuans/Scert/backend/internal/buildinfo"
|
||||
"git.pcux.cn/xuans/Scert/backend/internal/config"
|
||||
"git.pcux.cn/xuans/Scert/backend/internal/domain"
|
||||
)
|
||||
|
||||
type stubDomainRepository struct {
|
||||
items []domain.Domain
|
||||
created domain.Domain
|
||||
listErr error
|
||||
createErr error
|
||||
deleteErr error
|
||||
}
|
||||
|
||||
func (r *stubDomainRepository) Create(_ context.Context, item domain.Domain) error {
|
||||
r.created = item
|
||||
return r.createErr
|
||||
}
|
||||
|
||||
func (r *stubDomainRepository) GetByID(_ context.Context, _ string) (domain.Domain, error) {
|
||||
return domain.Domain{}, sql.ErrNoRows
|
||||
}
|
||||
|
||||
func (r *stubDomainRepository) List(_ context.Context) ([]domain.Domain, error) {
|
||||
return r.items, r.listErr
|
||||
}
|
||||
|
||||
func (r *stubDomainRepository) Delete(_ context.Context, _ string) error {
|
||||
return r.deleteErr
|
||||
}
|
||||
|
||||
func TestStatusReturnsApplicationAndConfigVersions(t *testing.T) {
|
||||
cfg := config.Default(t.TempDir())
|
||||
server := New(Dependencies{Config: cfg, Repository: &stubDomainRepository{}})
|
||||
response := httptest.NewRecorder()
|
||||
server.Handler().ServeHTTP(response, httptest.NewRequest(http.MethodGet, "/api/v1/status", nil))
|
||||
if response.Code != http.StatusOK {
|
||||
t.Fatalf("状态接口响应错误:%d", response.Code)
|
||||
}
|
||||
var payload struct {
|
||||
Version string `json:"version"`
|
||||
ConfigVersion int `json:"config_version"`
|
||||
}
|
||||
if err := json.Unmarshal(response.Body.Bytes(), &payload); err != nil {
|
||||
t.Fatalf("解析状态响应失败:%v", err)
|
||||
}
|
||||
if payload.Version != buildinfo.Version || payload.ConfigVersion != config.CurrentVersion {
|
||||
t.Fatalf("状态版本字段不正确:%+v", payload)
|
||||
}
|
||||
}
|
||||
|
||||
func TestDomainAPIValidatesSANAndHidesInternalErrors(t *testing.T) {
|
||||
cfg := config.Default(t.TempDir())
|
||||
repo := &stubDomainRepository{}
|
||||
server := New(Dependencies{Config: cfg, Repository: repo})
|
||||
|
||||
invalid := httptest.NewRequest(http.MethodPost, "/api/v1/domains", strings.NewReader(`{"name":"example.com","certificate_type":"san","sans":["bad_domain"]}`))
|
||||
invalid.Header.Set("Content-Type", "application/json")
|
||||
invalidResponse := httptest.NewRecorder()
|
||||
server.Handler().ServeHTTP(invalidResponse, invalid)
|
||||
if invalidResponse.Code != http.StatusBadRequest || strings.Contains(invalidResponse.Body.String(), "detail") {
|
||||
t.Fatalf("非法 SAN 响应不正确:%d %s", invalidResponse.Code, invalidResponse.Body.String())
|
||||
}
|
||||
|
||||
valid := httptest.NewRequest(http.MethodPost, "/api/v1/domains", strings.NewReader(`{"name":"example.com","certificate_type":"san","sans":["www.example.com"]}`))
|
||||
valid.Header.Set("Content-Type", "application/json")
|
||||
validResponse := httptest.NewRecorder()
|
||||
server.Handler().ServeHTTP(validResponse, valid)
|
||||
if validResponse.Code != http.StatusCreated || len(repo.created.SANs) != 2 || repo.created.SANs[0] != "example.com" {
|
||||
t.Fatalf("合法 SAN 响应不正确:%d %s", validResponse.Code, validResponse.Body.String())
|
||||
}
|
||||
|
||||
repo.listErr = errors.New("internal-dsn-secret")
|
||||
listResponse := httptest.NewRecorder()
|
||||
server.Handler().ServeHTTP(listResponse, httptest.NewRequest(http.MethodGet, "/api/v1/domains", nil))
|
||||
if listResponse.Code != http.StatusInternalServerError {
|
||||
t.Fatalf("列表错误状态码不正确:%d", listResponse.Code)
|
||||
}
|
||||
if strings.Contains(listResponse.Body.String(), "internal-dsn-secret") || strings.Contains(listResponse.Body.String(), "detail") {
|
||||
t.Fatalf("接口泄露了底层错误:%s", listResponse.Body.String())
|
||||
}
|
||||
}
|
||||
|
||||
func TestDeleteMissingDomainReturnsNotFound(t *testing.T) {
|
||||
cfg := config.Default(t.TempDir())
|
||||
repo := &stubDomainRepository{deleteErr: sql.ErrNoRows}
|
||||
server := New(Dependencies{Config: cfg, Repository: repo})
|
||||
response := httptest.NewRecorder()
|
||||
server.Handler().ServeHTTP(response, httptest.NewRequest(http.MethodDelete, "/api/v1/domains/missing", nil))
|
||||
if response.Code != http.StatusNotFound || strings.Contains(response.Body.String(), "detail") {
|
||||
t.Fatalf("删除不存在域名响应不正确:%d %s", response.Code, response.Body.String())
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,146 @@
|
||||
package httpapi
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"net"
|
||||
"net/http"
|
||||
"strconv"
|
||||
"time"
|
||||
|
||||
"github.com/gin-gonic/gin"
|
||||
|
||||
"git.pcux.cn/xuans/Scert/backend/internal/buildinfo"
|
||||
"git.pcux.cn/xuans/Scert/backend/internal/config"
|
||||
"git.pcux.cn/xuans/Scert/backend/internal/domain"
|
||||
"git.pcux.cn/xuans/Scert/backend/internal/logging"
|
||||
"git.pcux.cn/xuans/Scert/backend/internal/repository"
|
||||
)
|
||||
|
||||
type Dependencies struct {
|
||||
Config config.Config
|
||||
Logger *logging.Logger
|
||||
Repository repository.DomainRepository
|
||||
}
|
||||
|
||||
type Server struct {
|
||||
config config.Config
|
||||
logger *logging.Logger
|
||||
repository repository.DomainRepository
|
||||
httpServer *http.Server
|
||||
router *gin.Engine
|
||||
}
|
||||
|
||||
func New(deps Dependencies) *Server {
|
||||
gin.SetMode(gin.ReleaseMode)
|
||||
router := gin.New()
|
||||
router.Use(gin.Recovery())
|
||||
server := &Server{config: deps.Config, logger: deps.Logger, repository: deps.Repository, router: router}
|
||||
server.registerRoutes()
|
||||
return server
|
||||
}
|
||||
|
||||
func (s *Server) registerRoutes() {
|
||||
s.router.GET("/healthz", s.health)
|
||||
s.router.GET("/api/v1/status", s.status)
|
||||
s.router.GET("/api/v1/domains", s.listDomains)
|
||||
s.router.POST("/api/v1/domains", s.createDomain)
|
||||
s.router.DELETE("/api/v1/domains/:id", s.deleteDomain)
|
||||
}
|
||||
|
||||
func (s *Server) Handler() http.Handler {
|
||||
return s.router
|
||||
}
|
||||
|
||||
func (s *Server) ListenAndServe() error {
|
||||
s.httpServer = &http.Server{
|
||||
Addr: net.JoinHostPort(s.config.Server.Host, strconv.Itoa(s.config.Server.Port)),
|
||||
Handler: s.router,
|
||||
ReadHeaderTimeout: 10 * time.Second,
|
||||
ReadTimeout: 30 * time.Second,
|
||||
WriteTimeout: 30 * time.Second,
|
||||
IdleTimeout: 60 * time.Second,
|
||||
}
|
||||
if s.logger != nil {
|
||||
s.logger.Info("HTTP 服务启动", "address", s.httpServer.Addr, "https_mode", s.config.Server.HTTPSMode)
|
||||
}
|
||||
return s.httpServer.ListenAndServe()
|
||||
}
|
||||
|
||||
func (s *Server) Shutdown(ctx context.Context) error {
|
||||
if s.httpServer == nil {
|
||||
return nil
|
||||
}
|
||||
err := s.httpServer.Shutdown(ctx)
|
||||
if errors.Is(err, http.ErrServerClosed) {
|
||||
return nil
|
||||
}
|
||||
return err
|
||||
}
|
||||
|
||||
type createDomainRequest struct {
|
||||
Name string `json:"name" binding:"required"`
|
||||
CertificateType string `json:"certificate_type" binding:"required"`
|
||||
SANs []string `json:"sans"`
|
||||
}
|
||||
|
||||
func (s *Server) health(c *gin.Context) {
|
||||
c.JSON(http.StatusOK, gin.H{"status": "ok", "service": "scert"})
|
||||
}
|
||||
|
||||
func (s *Server) status(c *gin.Context) {
|
||||
c.JSON(http.StatusOK, gin.H{
|
||||
"service": "scert",
|
||||
"version": buildinfo.Version,
|
||||
"config_version": s.config.Version,
|
||||
"setup_ready": s.config.SetupReady,
|
||||
"https_mode": s.config.Server.HTTPSMode,
|
||||
"database_driver": s.config.Database.Driver,
|
||||
})
|
||||
}
|
||||
|
||||
func (s *Server) listDomains(c *gin.Context) {
|
||||
items, err := s.repository.List(c.Request.Context())
|
||||
if err != nil {
|
||||
s.writeError(c, http.StatusInternalServerError, "查询域名失败", err)
|
||||
return
|
||||
}
|
||||
c.JSON(http.StatusOK, gin.H{"items": items})
|
||||
}
|
||||
|
||||
func (s *Server) createDomain(c *gin.Context) {
|
||||
var request createDomainRequest
|
||||
if err := c.ShouldBindJSON(&request); err != nil {
|
||||
s.writeError(c, http.StatusBadRequest, "请求参数无效", err)
|
||||
return
|
||||
}
|
||||
item, err := domain.NewDomain(request.Name, domain.CertificateType(request.CertificateType), request.SANs)
|
||||
if err != nil {
|
||||
s.writeError(c, http.StatusBadRequest, "域名配置无效", err)
|
||||
return
|
||||
}
|
||||
if err := s.repository.Create(c.Request.Context(), item); err != nil {
|
||||
s.writeError(c, http.StatusInternalServerError, "保存域名失败", err)
|
||||
return
|
||||
}
|
||||
c.JSON(http.StatusCreated, item)
|
||||
}
|
||||
|
||||
func (s *Server) deleteDomain(c *gin.Context) {
|
||||
if err := s.repository.Delete(c.Request.Context(), c.Param("id")); err != nil {
|
||||
if repository.IsNotFound(err) {
|
||||
s.writeError(c, http.StatusNotFound, "域名不存在", err)
|
||||
return
|
||||
}
|
||||
s.writeError(c, http.StatusInternalServerError, "删除域名失败", err)
|
||||
return
|
||||
}
|
||||
c.Status(http.StatusNoContent)
|
||||
}
|
||||
|
||||
func (s *Server) writeError(c *gin.Context, status int, message string, err error) {
|
||||
if s.logger != nil {
|
||||
s.logger.Error(message, "error", err)
|
||||
}
|
||||
c.JSON(status, gin.H{"error": message})
|
||||
}
|
||||
@@ -0,0 +1,55 @@
|
||||
package httpapi
|
||||
|
||||
import (
|
||||
"context"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
"testing"
|
||||
|
||||
"git.pcux.cn/xuans/Scert/backend/internal/config"
|
||||
"git.pcux.cn/xuans/Scert/backend/internal/database"
|
||||
"git.pcux.cn/xuans/Scert/backend/internal/logging"
|
||||
"git.pcux.cn/xuans/Scert/backend/internal/repository"
|
||||
)
|
||||
|
||||
func TestHealthAndDomainAPI(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
cfg := config.Default(dir)
|
||||
cfg.Database.DSN = filepath.Join(dir, "data", "test.db")
|
||||
db, err := database.Open(context.Background(), cfg.Database)
|
||||
if err != nil {
|
||||
t.Fatalf("打开数据库失败:%v", err)
|
||||
}
|
||||
defer db.Close()
|
||||
if err := database.Migrate(context.Background(), db.DB, "sqlite"); err != nil {
|
||||
t.Fatalf("数据库迁移失败:%v", err)
|
||||
}
|
||||
logger, err := logging.New(filepath.Join(dir, "logs"), 0)
|
||||
if err != nil {
|
||||
t.Fatalf("初始化日志失败:%v", err)
|
||||
}
|
||||
defer logger.Close()
|
||||
server := New(Dependencies{Config: cfg, Logger: logger, Repository: repository.NewSQLDomainRepository(db.DB)})
|
||||
|
||||
health := httptest.NewRecorder()
|
||||
server.Handler().ServeHTTP(health, httptest.NewRequest(http.MethodGet, "/healthz", nil))
|
||||
if health.Code != http.StatusOK || !strings.Contains(health.Body.String(), `"status":"ok"`) {
|
||||
t.Fatalf("健康检查响应错误:%d %s", health.Code, health.Body.String())
|
||||
}
|
||||
|
||||
request := httptest.NewRequest(http.MethodPost, "/api/v1/domains", strings.NewReader(`{"name":"example.com","certificate_type":"single"}`))
|
||||
request.Header.Set("Content-Type", "application/json")
|
||||
created := httptest.NewRecorder()
|
||||
server.Handler().ServeHTTP(created, request)
|
||||
if created.Code != http.StatusCreated {
|
||||
t.Fatalf("创建域名响应错误:%d %s", created.Code, created.Body.String())
|
||||
}
|
||||
|
||||
list := httptest.NewRecorder()
|
||||
server.Handler().ServeHTTP(list, httptest.NewRequest(http.MethodGet, "/api/v1/domains", nil))
|
||||
if list.Code != http.StatusOK || !strings.Contains(list.Body.String(), "example.com") {
|
||||
t.Fatalf("域名列表响应错误:%d %s", list.Code, list.Body.String())
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,38 @@
|
||||
package logging
|
||||
|
||||
import (
|
||||
"io"
|
||||
"log/slog"
|
||||
"os"
|
||||
"path/filepath"
|
||||
)
|
||||
|
||||
type Logger struct {
|
||||
*slog.Logger
|
||||
file *os.File
|
||||
}
|
||||
|
||||
func New(logDir string, level slog.Level) (*Logger, error) {
|
||||
if err := os.MkdirAll(logDir, 0o750); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
path := filepath.Join(logDir, "scert.log")
|
||||
file, err := os.OpenFile(path, os.O_CREATE|os.O_APPEND|os.O_WRONLY, 0o600)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if err := file.Chmod(0o600); err != nil {
|
||||
_ = file.Close()
|
||||
return nil, err
|
||||
}
|
||||
writer := io.MultiWriter(os.Stdout, file)
|
||||
handler := slog.NewJSONHandler(writer, &slog.HandlerOptions{Level: level})
|
||||
return &Logger{Logger: slog.New(handler), file: file}, nil
|
||||
}
|
||||
|
||||
func (l *Logger) Close() error {
|
||||
if l == nil || l.file == nil {
|
||||
return nil
|
||||
}
|
||||
return l.file.Close()
|
||||
}
|
||||
@@ -0,0 +1,40 @@
|
||||
package logging
|
||||
|
||||
import (
|
||||
"log/slog"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"runtime"
|
||||
"strings"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestLoggerWritesJSONAndUsesRestrictedPermissions(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
logger, err := New(dir, slog.LevelInfo)
|
||||
if err != nil {
|
||||
t.Fatalf("初始化日志失败:%v", err)
|
||||
}
|
||||
logger.Info("复审日志", "component", "test")
|
||||
if err := logger.Close(); err != nil {
|
||||
t.Fatalf("关闭日志失败:%v", err)
|
||||
}
|
||||
path := filepath.Join(dir, "scert.log")
|
||||
data, err := os.ReadFile(path)
|
||||
if err != nil {
|
||||
t.Fatalf("读取日志失败:%v", err)
|
||||
}
|
||||
text := string(data)
|
||||
if !strings.Contains(text, `"msg":"复审日志"`) || !strings.Contains(text, `"component":"test"`) {
|
||||
t.Fatalf("日志内容不正确:%s", text)
|
||||
}
|
||||
if runtime.GOOS != "windows" {
|
||||
info, err := os.Stat(path)
|
||||
if err != nil {
|
||||
t.Fatalf("读取日志权限失败:%v", err)
|
||||
}
|
||||
if info.Mode().Perm() != 0o600 {
|
||||
t.Fatalf("日志文件权限不正确:%o", info.Mode().Perm())
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,14 @@
|
||||
package repository
|
||||
|
||||
import (
|
||||
"context"
|
||||
|
||||
"git.pcux.cn/xuans/Scert/backend/internal/domain"
|
||||
)
|
||||
|
||||
type DomainRepository interface {
|
||||
Create(ctx context.Context, item domain.Domain) error
|
||||
GetByID(ctx context.Context, id string) (domain.Domain, error)
|
||||
List(ctx context.Context) ([]domain.Domain, error)
|
||||
Delete(ctx context.Context, id string) error
|
||||
}
|
||||
@@ -0,0 +1,126 @@
|
||||
package repository
|
||||
|
||||
import (
|
||||
"context"
|
||||
"database/sql"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"fmt"
|
||||
"time"
|
||||
|
||||
"git.pcux.cn/xuans/Scert/backend/internal/domain"
|
||||
)
|
||||
|
||||
type SQLDomainRepository struct {
|
||||
db *sql.DB
|
||||
}
|
||||
|
||||
func NewSQLDomainRepository(db *sql.DB) *SQLDomainRepository {
|
||||
return &SQLDomainRepository{db: db}
|
||||
}
|
||||
|
||||
func (r *SQLDomainRepository) Create(ctx context.Context, item domain.Domain) error {
|
||||
if r == nil || r.db == nil {
|
||||
return errors.New("数据库连接不能为空")
|
||||
}
|
||||
payload, err := json.Marshal(item.SANs)
|
||||
if err != nil {
|
||||
return fmt.Errorf("编码 SAN 域名失败:%w", err)
|
||||
}
|
||||
_, err = r.db.ExecContext(ctx, `INSERT INTO domains
|
||||
(id, name, certificate_type, sans_json, status, expires_at, created_at, updated_at)
|
||||
VALUES (?, ?, ?, ?, ?, ?, ?, ?)`, item.ID, item.Name, item.CertificateType, string(payload), item.Status,
|
||||
nullableTime(item.ExpiresAt), item.CreatedAt, item.UpdatedAt)
|
||||
if err != nil {
|
||||
return fmt.Errorf("保存域名失败:%w", err)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (r *SQLDomainRepository) GetByID(ctx context.Context, id string) (domain.Domain, error) {
|
||||
if r == nil || r.db == nil {
|
||||
return domain.Domain{}, errors.New("数据库连接不能为空")
|
||||
}
|
||||
row := r.db.QueryRowContext(ctx, `SELECT id, name, certificate_type, sans_json, status, expires_at, created_at, updated_at
|
||||
FROM domains WHERE id = ?`, id)
|
||||
return scanDomain(row)
|
||||
}
|
||||
|
||||
func (r *SQLDomainRepository) List(ctx context.Context) ([]domain.Domain, error) {
|
||||
if r == nil || r.db == nil {
|
||||
return nil, errors.New("数据库连接不能为空")
|
||||
}
|
||||
rows, err := r.db.QueryContext(ctx, `SELECT id, name, certificate_type, sans_json, status, expires_at, created_at, updated_at
|
||||
FROM domains ORDER BY name`)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("查询域名失败:%w", err)
|
||||
}
|
||||
defer rows.Close()
|
||||
items := make([]domain.Domain, 0)
|
||||
for rows.Next() {
|
||||
item, err := scanDomain(rows)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
items = append(items, item)
|
||||
}
|
||||
if err := rows.Err(); err != nil {
|
||||
return nil, fmt.Errorf("读取域名结果失败:%w", err)
|
||||
}
|
||||
return items, nil
|
||||
}
|
||||
|
||||
func (r *SQLDomainRepository) Delete(ctx context.Context, id string) error {
|
||||
if r == nil || r.db == nil {
|
||||
return errors.New("数据库连接不能为空")
|
||||
}
|
||||
result, err := r.db.ExecContext(ctx, "DELETE FROM domains WHERE id = ?", id)
|
||||
if err != nil {
|
||||
return fmt.Errorf("删除域名失败:%w", err)
|
||||
}
|
||||
count, err := result.RowsAffected()
|
||||
if err != nil {
|
||||
return fmt.Errorf("读取删除结果失败:%w", err)
|
||||
}
|
||||
if count == 0 {
|
||||
return sql.ErrNoRows
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
type scanner interface {
|
||||
Scan(dest ...any) error
|
||||
}
|
||||
|
||||
func scanDomain(row scanner) (domain.Domain, error) {
|
||||
var item domain.Domain
|
||||
var certificateType string
|
||||
var sansJSON string
|
||||
var expiresAt sql.NullTime
|
||||
if err := row.Scan(&item.ID, &item.Name, &certificateType, &sansJSON, &item.Status, &expiresAt, &item.CreatedAt, &item.UpdatedAt); err != nil {
|
||||
if errors.Is(err, sql.ErrNoRows) {
|
||||
return domain.Domain{}, sql.ErrNoRows
|
||||
}
|
||||
return domain.Domain{}, fmt.Errorf("读取域名失败:%w", err)
|
||||
}
|
||||
if err := json.Unmarshal([]byte(sansJSON), &item.SANs); err != nil {
|
||||
return domain.Domain{}, fmt.Errorf("解析 SAN 域名失败:%w", err)
|
||||
}
|
||||
item.CertificateType = domain.CertificateType(certificateType)
|
||||
if expiresAt.Valid {
|
||||
value := expiresAt.Time
|
||||
item.ExpiresAt = &value
|
||||
}
|
||||
return item, nil
|
||||
}
|
||||
|
||||
func nullableTime(value *time.Time) any {
|
||||
if value == nil {
|
||||
return nil
|
||||
}
|
||||
return value.UTC()
|
||||
}
|
||||
|
||||
func IsNotFound(err error) bool {
|
||||
return err != nil && errors.Is(err, sql.ErrNoRows)
|
||||
}
|
||||
@@ -0,0 +1,78 @@
|
||||
package repository
|
||||
|
||||
import (
|
||||
"context"
|
||||
"database/sql"
|
||||
"path/filepath"
|
||||
"testing"
|
||||
|
||||
"git.pcux.cn/xuans/Scert/backend/internal/config"
|
||||
"git.pcux.cn/xuans/Scert/backend/internal/database"
|
||||
"git.pcux.cn/xuans/Scert/backend/internal/domain"
|
||||
)
|
||||
|
||||
func TestRepositoryRejectsNilDatabase(t *testing.T) {
|
||||
var repo *SQLDomainRepository
|
||||
ctx := context.Background()
|
||||
item, err := domain.NewDomain("example.com", domain.CertificateSingle, nil)
|
||||
if err != nil {
|
||||
t.Fatalf("准备域名失败:%v", err)
|
||||
}
|
||||
if err := repo.Create(ctx, item); err == nil {
|
||||
t.Fatal("Create 未拒绝空数据库")
|
||||
}
|
||||
if _, err := repo.GetByID(ctx, item.ID); err == nil {
|
||||
t.Fatal("GetByID 未拒绝空数据库")
|
||||
}
|
||||
if _, err := repo.List(ctx); err == nil {
|
||||
t.Fatal("List 未拒绝空数据库")
|
||||
}
|
||||
if err := repo.Delete(ctx, item.ID); err == nil {
|
||||
t.Fatal("Delete 未拒绝空数据库")
|
||||
}
|
||||
if IsNotFound(nil) {
|
||||
t.Fatal("nil 错误不应被识别为未找到")
|
||||
}
|
||||
if !IsNotFound(sql.ErrNoRows) {
|
||||
t.Fatal("sql.ErrNoRows 未被识别为未找到")
|
||||
}
|
||||
}
|
||||
|
||||
func TestRepositoryCRUD(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
cfg := config.Default(dir).Database
|
||||
cfg.DSN = filepath.Join(dir, "data", "repository.db")
|
||||
db, err := database.Open(context.Background(), cfg)
|
||||
if err != nil {
|
||||
t.Fatalf("打开数据库失败:%v", err)
|
||||
}
|
||||
defer db.Close()
|
||||
if err := database.Migrate(context.Background(), db.DB, "sqlite"); err != nil {
|
||||
t.Fatalf("迁移数据库失败:%v", err)
|
||||
}
|
||||
repo := NewSQLDomainRepository(db.DB)
|
||||
item, err := domain.NewDomain("example.com", domain.CertificateSAN, []string{"www.example.com"})
|
||||
if err != nil {
|
||||
t.Fatalf("创建域名模型失败:%v", err)
|
||||
}
|
||||
if err := repo.Create(context.Background(), item); err != nil {
|
||||
t.Fatalf("保存域名失败:%v", err)
|
||||
}
|
||||
loaded, err := repo.GetByID(context.Background(), item.ID)
|
||||
if err != nil {
|
||||
t.Fatalf("读取域名失败:%v", err)
|
||||
}
|
||||
if loaded.Name != item.Name || len(loaded.SANs) != 2 {
|
||||
t.Fatalf("读取域名内容不正确:%+v", loaded)
|
||||
}
|
||||
items, err := repo.List(context.Background())
|
||||
if err != nil || len(items) != 1 {
|
||||
t.Fatalf("域名列表不正确:%v,%+v", err, items)
|
||||
}
|
||||
if err := repo.Delete(context.Background(), item.ID); err != nil {
|
||||
t.Fatalf("删除域名失败:%v", err)
|
||||
}
|
||||
if err := repo.Delete(context.Background(), item.ID); !IsNotFound(err) {
|
||||
t.Fatalf("重复删除未返回未找到:%v", err)
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user