完成Scert首轮基础骨架开发与复审

This commit is contained in:
xuans committed 2026-08-26 10:34:04 +08:00
commit fd8d8608f5
41 files changed
+6987

No files matched your search

+79
View File
@@ -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)
}
+7
View File
@@ -0,0 +1,7 @@
package app
import "os"
var osMkdirAll = func(path string) error {
return os.MkdirAll(path, 0o750)
}
+3
View File
@@ -0,0 +1,3 @@
package buildinfo
const Version = "0.1.0"
+234
View File
@@ -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")
}
+60
View File
@@ -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)
}
}
+183
View File
@@ -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
}
+44
View File
@@ -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("无效端口未被拒绝")
}
}
+45
View File
@@ -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())
}
}
}
+90
View File
@@ -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)
}
}
+7
View File
@@ -0,0 +1,7 @@
package database
import "os"
func makeDirectory(path string) error {
return os.MkdirAll(path, 0o750)
}
+97
View File
@@ -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
);
+68
View File
@@ -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("未知迁移驱动未被拒绝")
}
}
+99
View File
@@ -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])
}
+57
View File
@@ -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 域名未被拒绝")
}
}
+104
View File
@@ -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())
}
}
+146
View File
@@ -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})
}
+55
View File
@@ -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())
}
}
+38
View File
@@ -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()
}
+40
View File
@@ -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)
}
}