生产部署整改阶段检查点

This commit is contained in:
xuans committed 2026-08-31 23:33:56 +08:00
1 parent f3348cf95d
commit 92d4b3d398
56 files changed
+4178 -240

No files matched your search

+1
View File
@@ -76,6 +76,7 @@ func isCoreRequestPath(path string) bool {
return path == "/api" ||
strings.HasPrefix(path, "/api/") ||
path == "/healthz" ||
path == "/readyz" ||
path == "/reset" ||
strings.HasPrefix(path, "/reset/")
}
+197
View File
@@ -0,0 +1,197 @@
package httpapi
import (
"context"
"errors"
"net/http"
"net/http/httptest"
"os"
"path/filepath"
"strings"
"testing"
"git.pcux.cn/xuans/Scert/backend/internal/config"
"git.pcux.cn/xuans/Scert/backend/internal/secretstore"
)
const readinessDNSReference = "secret://dns/cloudflare/readiness-test"
func TestReadinessRejectsIncompleteSetup(t *testing.T) {
cfg := config.Default(t.TempDir())
response := requestReadiness(New(Dependencies{Config: cfg}))
assertReadinessResponse(t, response, http.StatusServiceUnavailable, "setup_incomplete")
}
func TestReadinessRejectsMissingDNSCredentialReference(t *testing.T) {
cfg := readinessConfig(t)
cfg.DNS.CredentialRef = ""
response := requestReadiness(New(Dependencies{Config: cfg}))
assertReadinessResponse(t, response, http.StatusServiceUnavailable, "dns_credential_missing")
}
func TestReadinessRejectsUnavailableCredentialWithoutLeakingReference(t *testing.T) {
cfg := readinessConfig(t)
store, err := secretstore.Open(filepath.Join(t.TempDir(), "secrets"))
if err != nil {
t.Fatalf("打开测试敏感信息存储失败:%v", err)
}
response := requestReadiness(New(Dependencies{Config: cfg, Secrets: store}))
assertReadinessResponse(t, response, http.StatusServiceUnavailable, "credential_unavailable")
if strings.Contains(response.Body.String(), readinessDNSReference) || strings.Contains(response.Body.String(), "secret://") {
t.Fatalf("生产就绪响应泄漏敏感信息引用:%s", response.Body.String())
}
}
func TestReadinessChecksConfiguredNotificationCredentials(t *testing.T) {
tests := []struct {
name string
configure func(*config.Config)
}{
{
name: "HTTP notification",
configure: func(cfg *config.Config) {
cfg.Notification.HTTPCredentialRef = "secret://notification/http/readiness-test"
},
},
{
name: "SMTP notification",
configure: func(cfg *config.Config) {
cfg.Notification.SMTPCredentialRef = "secret://notification/smtp/readiness-test"
},
},
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
cfg := readinessConfig(t)
test.configure(&cfg)
store := readinessStore(t)
response := requestReadiness(New(Dependencies{Config: cfg, Secrets: store}))
assertReadinessResponse(t, response, http.StatusServiceUnavailable, "credential_unavailable")
})
}
}
func TestReadinessRejectsInvalidTLSMaterial(t *testing.T) {
tests := []struct {
name string
configure func(*testing.T, *config.Config)
}{
{
name: "missing file",
configure: func(t *testing.T, cfg *config.Config) {
cfg.Server.TLSCert = filepath.Join(t.TempDir(), "missing.pem")
},
},
{
name: "directory",
configure: func(t *testing.T, cfg *config.Config) {
cfg.Server.TLSKey = t.TempDir()
},
},
{
name: "symbolic link",
configure: func(t *testing.T, cfg *config.Config) {
target := filepath.Join(t.TempDir(), "target.pem")
if err := os.WriteFile(target, []byte("test"), 0o600); err != nil {
t.Fatalf("写入符号链接目标失败:%v", err)
}
link := filepath.Join(t.TempDir(), "linked.pem")
if err := os.Symlink(target, link); err != nil {
t.Skipf("当前环境无法创建符号链接:%v", err)
}
cfg.Server.TLSCert = link
},
},
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
cfg := readinessConfig(t)
test.configure(t, &cfg)
response := requestReadiness(New(Dependencies{Config: cfg, Secrets: readinessStore(t)}))
assertReadinessResponse(t, response, http.StatusServiceUnavailable, "tls_material_unavailable")
})
}
}
func TestReadinessRejectsUnavailableDatabase(t *testing.T) {
cfg := readinessConfig(t)
response := requestReadiness(New(Dependencies{
Config: cfg,
Secrets: readinessStore(t),
ReadinessCheck: func(_ context.Context) error {
return errors.New("database unavailable")
},
}))
assertReadinessResponse(t, response, http.StatusServiceUnavailable, "database_unavailable")
}
func TestReadinessSucceedsWhenDependenciesAreAvailable(t *testing.T) {
cfg := readinessConfig(t)
response := requestReadiness(New(Dependencies{
Config: cfg,
Secrets: readinessStore(t),
ReadinessCheck: func(_ context.Context) error {
return nil
},
}))
assertReadinessResponse(t, response, http.StatusOK, "ready")
}
func TestReadinessIsNotHandledByFrontendFallback(t *testing.T) {
staticDir := t.TempDir()
if err := os.WriteFile(filepath.Join(staticDir, "index.html"), []byte("frontend fallback"), 0o644); err != nil {
t.Fatalf("写入前端入口失败:%v", err)
}
cfg := config.Default(t.TempDir())
response := requestReadiness(New(Dependencies{Config: cfg, FrontendDir: staticDir}))
assertReadinessResponse(t, response, http.StatusServiceUnavailable, "setup_incomplete")
if strings.Contains(response.Body.String(), "frontend fallback") {
t.Fatalf("生产就绪路径被前端回退接管:%s", response.Body.String())
}
}
func readinessConfig(t *testing.T) config.Config {
t.Helper()
directory := t.TempDir()
cfg := config.Default(directory)
cfg.SetupReady = true
cfg.DNS.CredentialRef = readinessDNSReference
cfg.Server.TLSCert = filepath.Join(directory, "server.crt")
cfg.Server.TLSKey = filepath.Join(directory, "server.key")
if err := os.WriteFile(cfg.Server.TLSCert, []byte("certificate"), 0o644); err != nil {
t.Fatalf("写入测试证书失败:%v", err)
}
if err := os.WriteFile(cfg.Server.TLSKey, []byte("private key"), 0o600); err != nil {
t.Fatalf("写入测试私钥失败:%v", err)
}
return cfg
}
func readinessStore(t *testing.T) *secretstore.Store {
t.Helper()
store, err := secretstore.Open(filepath.Join(t.TempDir(), "secrets"))
if err != nil {
t.Fatalf("打开测试敏感信息存储失败:%v", err)
}
if err := store.Put(t.Context(), readinessDNSReference, map[string]string{"api_token": "readiness-test-token"}); err != nil {
t.Fatalf("写入测试 DNS 凭据失败:%v", err)
}
return store
}
func requestReadiness(server *Server) *httptest.ResponseRecorder {
response := httptest.NewRecorder()
server.Handler().ServeHTTP(response, httptest.NewRequest(http.MethodGet, "/readyz", nil))
return response
}
func assertReadinessResponse(t *testing.T, response *httptest.ResponseRecorder, wantStatus int, wantState string) {
t.Helper()
if response.Code != wantStatus {
t.Fatalf("生产就绪状态码 = %d,期望 %d,响应:%s", response.Code, wantStatus, response.Body.String())
}
if !strings.Contains(response.Body.String(), `"status":"`+wantState+`"`) &&
!strings.Contains(response.Body.String(), `"reason":"`+wantState+`"`) {
t.Fatalf("生产就绪响应缺少状态 %q:%s", wantState, response.Body.String())
}
}
+32
View File
@@ -2,6 +2,7 @@ package httpapi
import (
"context"
"crypto/tls"
"database/sql"
"encoding/json"
"errors"
@@ -83,6 +84,37 @@ func TestStatusReturnsApplicationAndConfigVersions(t *testing.T) {
}
}
func TestPublicStatusDoesNotExposeInternalConfiguration(t *testing.T) {
cfg := readyTestConfig(t.TempDir())
cfg.Database.Driver = "mysql"
cfg.Server.HTTPSMode = "proxy"
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 map[string]any
if err := json.Unmarshal(response.Body.Bytes(), &payload); err != nil {
t.Fatalf("解析公开状态响应失败:%v", err)
}
for _, key := range []string{"database_driver", "https_mode", "reset_url"} {
if _, exists := payload[key]; exists {
t.Fatalf("公开状态接口不应返回内部字段 %s:%s", key, response.Body.String())
}
}
}
func TestHTTPServerUsesProductionTimeoutsAndTLSMinimum(t *testing.T) {
server := newHTTPServer("127.0.0.1:0", http.NewServeMux())
if server.ReadHeaderTimeout != 10*time.Second || server.ReadTimeout != 30*time.Second || server.WriteTimeout != 30*time.Second || server.IdleTimeout != 60*time.Second {
t.Fatalf("HTTP 服务超时配置不正确:%+v", server)
}
if server.TLSConfig == nil || server.TLSConfig.MinVersion != tls.VersionTLS12 {
t.Fatalf("TLS 最低版本应为 TLS 1.2:%+v", server.TLSConfig)
}
}
func TestDomainAPIValidatesSANAndHidesInternalErrors(t *testing.T) {
cfg := readyTestConfig(t.TempDir())
repo := &stubDomainRepository{}
+107 -18
View File
@@ -2,6 +2,7 @@ package httpapi
import (
"context"
"crypto/tls"
"database/sql"
"errors"
"fmt"
@@ -33,6 +34,10 @@ type setupSecretWriter interface {
Delete(context.Context, string) error
}
type readinessSecretReader interface {
Get(context.Context, string) (map[string]string, error)
}
type Dependencies struct {
Config config.Config
ConfigPath string
@@ -58,6 +63,7 @@ type Dependencies struct {
ResetStatePath string
Audit repository.AuditRepository
Tasks repository.TaskRepository
ReadinessCheck func(context.Context) error
}
type Server struct {
@@ -86,6 +92,7 @@ type Server struct {
resetStatePath string
audit repository.AuditRepository
tasks repository.TaskRepository
readinessCheck func(context.Context) error
taskMu sync.Mutex
taskCancels map[string]context.CancelFunc
issueTaskMu sync.Mutex
@@ -127,6 +134,7 @@ func New(deps Dependencies) *Server {
resetStatePath: deps.ResetStatePath,
audit: deps.Audit,
tasks: deps.Tasks,
readinessCheck: deps.ReadinessCheck,
taskCancels: make(map[string]context.CancelFunc),
resetLimiter: newResetRateLimiter(),
authSessions: make(map[string]authSession),
@@ -142,6 +150,7 @@ func New(deps Dependencies) *Server {
func (s *Server) registerRoutes() {
// 主路由保持独立,初始化路由由专用模块注册。
s.router.GET("/healthz", s.health)
s.router.GET("/readyz", s.ready)
s.router.GET(admin.ResetPath, s.resetPage)
s.router.POST(admin.ResetPath, s.resetSubmit)
s.router.GET("/api/v1/status", s.status)
@@ -204,14 +213,7 @@ func (s *Server) ListenAndServe() error {
if err != nil {
return err
}
s.httpServer = &http.Server{
Addr: address,
Handler: s.router,
ReadHeaderTimeout: 10 * time.Second,
ReadTimeout: 30 * time.Second,
WriteTimeout: 30 * time.Second,
IdleTimeout: 60 * time.Second,
}
s.httpServer = newHTTPServer(address, s.router)
if !cfg.SetupReady {
if s.logger != nil {
s.logger.Info("HTTP 服务启动", "address", s.httpServer.Addr, "https_mode", "初始化明文 HTTP")
@@ -235,6 +237,20 @@ func (s *Server) ListenAndServe() error {
return s.httpServer.ListenAndServeTLS(certPath, keyPath)
}
func newHTTPServer(address string, handler http.Handler) *http.Server {
return &http.Server{
Addr: address,
Handler: handler,
ReadHeaderTimeout: 10 * time.Second,
ReadTimeout: 30 * time.Second,
WriteTimeout: 30 * time.Second,
IdleTimeout: 60 * time.Second,
TLSConfig: &tls.Config{
MinVersion: tls.VersionTLS12,
},
}
}
// listenAddress 返回当前 HTTPS 模式实际使用的监听地址。
// 高级模式的核心服务只允许通过本机回环地址提供内部 HTTPS,避免误绑定到公网网卡。
func listenAddress(cfg config.Config) (string, error) {
@@ -291,6 +307,7 @@ type serverRequest struct {
PrivateKeyPath string `json:"private_key_path"`
CertificateChainPath string `json:"certificate_chain_path"`
WebServer string `json:"web_server" binding:"required"`
ValidationCommand []string `json:"validation_command"`
ReloadCommand []string `json:"reload_command"`
}
@@ -302,6 +319,71 @@ func (s *Server) health(c *gin.Context) {
c.JSON(http.StatusOK, gin.H{"status": "ok", "service": "scert"})
}
func (s *Server) ready(c *gin.Context) {
s.configMu.RLock()
cfg := s.config
s.configMu.RUnlock()
if !cfg.SetupReady {
s.writeReadinessFailure(c, "setup_incomplete")
return
}
dnsReference := strings.TrimSpace(cfg.DNS.CredentialRef)
if dnsReference == "" {
s.writeReadinessFailure(c, "dns_credential_missing")
return
}
references := []string{
dnsReference,
strings.TrimSpace(cfg.Notification.HTTPCredentialRef),
strings.TrimSpace(cfg.Notification.SMTPCredentialRef),
}
reader, ok := s.secrets.(readinessSecretReader)
if !ok {
s.writeReadinessFailure(c, "secret_store_unavailable")
return
}
ctx, cancel := context.WithTimeout(c.Request.Context(), 3*time.Second)
defer cancel()
checked := make(map[string]struct{}, len(references))
for _, reference := range references {
if reference == "" {
continue
}
if _, exists := checked[reference]; exists {
continue
}
checked[reference] = struct{}{}
if _, err := reader.Get(ctx, reference); err != nil {
s.writeReadinessFailure(c, "credential_unavailable")
return
}
}
for _, path := range []string{cfg.Server.TLSCert, cfg.Server.TLSKey} {
info, err := os.Lstat(filepath.Clean(strings.TrimSpace(path)))
if err != nil || info.Mode()&os.ModeSymlink != 0 || !info.Mode().IsRegular() {
s.writeReadinessFailure(c, "tls_material_unavailable")
return
}
}
if s.readinessCheck != nil {
if err := s.readinessCheck(ctx); err != nil {
s.writeReadinessFailure(c, "database_unavailable")
return
}
}
c.JSON(http.StatusOK, gin.H{"status": "ready", "service": "scert"})
}
func (s *Server) writeReadinessFailure(c *gin.Context, reason string) {
c.JSON(http.StatusServiceUnavailable, gin.H{
"status": "not_ready",
"service": "scert",
"reason": reason,
})
}
func (s *Server) resetPage(c *gin.Context) {
s.resetMu.Lock()
defer s.resetMu.Unlock()
@@ -323,15 +405,18 @@ func (s *Server) status(c *gin.Context) {
s.configMu.RLock()
cfg := s.config
s.configMu.RUnlock()
c.JSON(http.StatusOK, gin.H{
"service": "scert",
"version": buildinfo.Version,
"config_version": cfg.Version,
"setup_ready": cfg.SetupReady,
"https_mode": cfg.Server.HTTPSMode,
"database_driver": cfg.Database.Driver,
"reset_url": cfg.ResetURL(),
})
payload := gin.H{
"service": "scert",
"version": buildinfo.Version,
"config_version": cfg.Version,
"setup_ready": cfg.SetupReady,
}
if _, authenticated := s.currentAuthSession(c); authenticated {
payload["https_mode"] = cfg.Server.HTTPSMode
payload["database_driver"] = cfg.Database.Driver
payload["reset_url"] = cfg.ResetURL()
}
c.JSON(http.StatusOK, payload)
}
func (s *Server) requireDomainRepository(c *gin.Context) bool {
@@ -521,6 +606,9 @@ func (s *Server) createServer(c *gin.Context) {
}
item := serverFromRequest(request)
item = item.Normalize()
now := time.Now().UTC()
item.CreatedAt = now
item.UpdatedAt = now
if err := s.validateSSHKeyReference(c.Request.Context(), item.PrivateKeyRef); err != nil {
s.writeError(c, http.StatusBadRequest, "SSH 私钥引用无效", err)
return
@@ -555,6 +643,7 @@ func (s *Server) updateServer(c *gin.Context) {
return
}
item.CreatedAt = existing.CreatedAt
item.UpdatedAt = time.Now().UTC()
if err := s.validateSSHKeyReference(c.Request.Context(), item.PrivateKeyRef); err != nil {
s.writeError(c, http.StatusBadRequest, "SSH 私钥引用无效", err)
return
@@ -653,7 +742,7 @@ func serverFromRequest(request serverRequest) deployment.Server {
Username: request.Username, PrivateKeyRef: request.PrivateKeyRef, HostKeyFingerprint: request.HostKeyFingerprint,
CertificatePath: request.CertificatePath, PrivateKeyPath: request.PrivateKeyPath,
CertificateChainPath: request.CertificateChainPath, WebServer: deployment.WebServer(request.WebServer),
ReloadCommand: request.ReloadCommand,
ValidationCommand: request.ValidationCommand, ReloadCommand: request.ReloadCommand,
}
}
+19 -1
View File
@@ -332,13 +332,31 @@ func TestServerAndDomainAssociationAPI(t *testing.T) {
t.Fatalf("创建测试服务器失败:%d %s", serverResponse.Code, serverResponse.Body.String())
}
var created deployment.Server
if err := json.Unmarshal(serverResponse.Body.Bytes(), &created); err != nil || created.ID == "" || len(created.ReloadCommand) != 3 {
if err := json.Unmarshal(serverResponse.Body.Bytes(), &created); err != nil || created.ID == "" || len(created.ValidationCommand) != 2 || created.ValidationCommand[1] != "-t" || len(created.ReloadCommand) != 3 {
t.Fatalf("测试服务器响应无效:%v %+v", err, created)
}
if created.CreatedAt.IsZero() || created.UpdatedAt.IsZero() {
t.Fatalf("created server response has zero timestamps: %+v", created)
}
if created.CertificatePath != deployment.DefaultCertificatePath || created.CertificateChainPath != deployment.DefaultCertificateChainPath || created.PrivateKeyPath != deployment.DefaultPrivateKeyPath {
t.Fatalf("服务器 API 未使用默认远程证书路径模板:%+v", created)
}
updateRequest := httptest.NewRequest(http.MethodPut, "/api/v1/servers/"+created.ID, strings.NewReader(`{"name":"updated-server","address":"192.0.2.50","port":22,"username":"deploy","private_key_ref":"`+key.Reference+`","host_key_fingerprint":"SHA256:test","web_server":"nginx"}`))
updateRequest.Header.Set("Content-Type", "application/json")
updateResponse := httptest.NewRecorder()
serveAdminHTTP(server, updateResponse, updateRequest)
if updateResponse.Code != http.StatusOK {
t.Fatalf("update server failed: %d %s", updateResponse.Code, updateResponse.Body.String())
}
var updated deployment.Server
if err := json.Unmarshal(updateResponse.Body.Bytes(), &updated); err != nil {
t.Fatalf("decode updated server response: %v", err)
}
if updated.Name != "updated-server" || updated.CreatedAt.IsZero() || updated.UpdatedAt.IsZero() {
t.Fatalf("updated server response is incomplete: %+v", updated)
}
associationRequest := httptest.NewRequest(http.MethodPut, "/api/v1/domains/"+item.ID+"/servers", strings.NewReader(`{"server_ids":["`+created.ID+`"]}`))
associationRequest.Header.Set("Content-Type", "application/json")
associationResponse := httptest.NewRecorder()
+9
View File
@@ -102,6 +102,15 @@ func (s *Server) setupStatus(c *gin.Context) {
blockers = append(blockers, "DNS API 尚未验证")
}
}
if cfg.SetupReady {
c.JSON(http.StatusOK, gin.H{
"initialized": cfg.SetupReady,
"phase": phase,
"blockers": blockers,
"web_enabled": cfg.Web.Enabled,
})
return
}
c.JSON(http.StatusOK, gin.H{
"initialized": cfg.SetupReady,
"phase": phase,
+32
View File
@@ -177,6 +177,38 @@ func TestSetupStatusOnlyAllowsLocalAccessBeforeInitialization(t *testing.T) {
}
}
func TestSetupStatusHidesConfigurationAfterInitialization(t *testing.T) {
cfg := readyTestConfig(t.TempDir())
cfg.Server.Port = 9004
cfg.Server.HTTPSMode = "proxy"
cfg.Web.Hostname = "internal.example.test"
cfg.Web.PublicIP = "192.0.2.20"
cfg.Paths.Certificate = filepath.Join(t.TempDir(), "private-certificates")
cfg.DNS.Provider = "cloudflare"
cfg.DNS.VerificationState = "verified"
server := New(Dependencies{Config: cfg, Repository: &stubDomainRepository{}})
request := httptest.NewRequest(http.MethodGet, "/api/v1/setup/status", nil)
request.RemoteAddr = "203.0.113.8:53000"
response := httptest.NewRecorder()
server.Handler().ServeHTTP(response, request)
if response.Code != http.StatusOK {
t.Fatalf("初始化完成后的状态接口响应错误:%d %s", response.Code, response.Body.String())
}
var payload map[string]any
if err := json.Unmarshal(response.Body.Bytes(), &payload); err != nil {
t.Fatalf("解析初始化状态失败:%v", err)
}
if payload["initialized"] != true {
t.Fatalf("初始化状态不正确:%s", response.Body.String())
}
for _, key := range []string{"server_port", "reset_url", "https_mode", "web_hostname", "web_public_ip", "certificate_root", "dns_provider", "dns_verification_state"} {
if _, exists := payload[key]; exists {
t.Fatalf("初始化完成后不应公开内部字段 %s:%s", key, response.Body.String())
}
}
}
func TestSetupDNSProviderCatalogAndOnlineTest(t *testing.T) {
cfg := config.Default(t.TempDir())
verifier := &fakeSetupDNSVerifier{}