整理前后端与测试构建目录并完善配置和安全引导
Security Checks / security (push) Waiting to run

统一 frontend、backend、test、test-log 和 out 目录,更新构建、部署及测试入口;纳入配置管理兼容与首次安全引导修复;排除本机配置、密钥和测试产物。
This commit is contained in:
xuans committed 2026-09-05 19:19:52 +08:00
1 parent 28cd9d3406
commit f60d3b0880
603 files changed
+2351 -660

No files matched your search

+244
View File
@@ -0,0 +1,244 @@
package release
import (
"encoding/json"
"errors"
"fmt"
"io"
"os"
"path/filepath"
"runtime"
"strings"
"time"
"git.pcux.cn/xuans/Smail/internal/buildinfo"
)
var (
ErrInvalidPair = errors.New("invalid release pair")
ErrUpgradeRollback = errors.New("release upgrade rolled back")
ErrUpgradeDirectory = errors.New("release target directory is invalid")
)
type Manifest struct {
Version string `json:"version"`
GitHash string `json:"gitHash"`
ProtocolVersion int `json:"protocolVersion"`
CreatedAt string `json:"createdAt"`
}
type Pair struct {
Main buildinfo.Info
Admin buildinfo.Info
}
func NewManifest(pair Pair, now time.Time) (Manifest, error) {
if err := buildinfo.ValidatePair(pair.Main, pair.Admin); err != nil {
return Manifest{}, fmt.Errorf("%w: %v", ErrInvalidPair, err)
}
if now.IsZero() {
now = time.Now().UTC()
}
return Manifest{
Version: pair.Main.Version,
GitHash: pair.Main.GitHash,
ProtocolVersion: pair.Main.ProtocolVersion,
CreatedAt: now.UTC().Format(time.RFC3339),
}, nil
}
func ValidateManifest(manifest Manifest, pair Pair) error {
if err := buildinfo.ValidatePair(pair.Main, pair.Admin); err != nil {
return fmt.Errorf("%w: %v", ErrInvalidPair, err)
}
if strings.TrimSpace(manifest.Version) == "" || manifest.ProtocolVersion != buildinfo.ProtocolVersion {
return ErrInvalidPair
}
if _, err := time.Parse(time.RFC3339, manifest.CreatedAt); err != nil {
return ErrInvalidPair
}
if manifest.Version != pair.Main.Version || manifest.ProtocolVersion != pair.Main.ProtocolVersion {
return ErrInvalidPair
}
if known(manifest.GitHash) && known(pair.Main.GitHash) && manifest.GitHash != pair.Main.GitHash {
return ErrInvalidPair
}
return nil
}
func InstallPair(mainSource, adminSource, targetDir string, pair Pair) error {
if strings.TrimSpace(targetDir) == "" || filepath.Clean(targetDir) == "." {
return ErrUpgradeDirectory
}
manifest, err := NewManifest(pair, time.Now().UTC())
if err != nil {
return err
}
mainName, adminName := executableNames()
if err := validateExecutableSource(mainSource); err != nil {
return fmt.Errorf("validate main executable: %w", err)
}
if err := validateExecutableSource(adminSource); err != nil {
return fmt.Errorf("validate admin executable: %w", err)
}
parent := filepath.Dir(filepath.Clean(targetDir))
if err := os.MkdirAll(parent, 0750); err != nil {
return fmt.Errorf("create release parent: %w", err)
}
stage, err := os.MkdirTemp(parent, ".smail-release-")
if err != nil {
return fmt.Errorf("create release staging directory: %w", err)
}
defer os.RemoveAll(stage)
if err := copyExecutable(mainSource, filepath.Join(stage, mainName), 0755); err != nil {
return fmt.Errorf("stage main executable: %w", err)
}
if err := copyExecutable(adminSource, filepath.Join(stage, adminName), 0750); err != nil {
return fmt.Errorf("stage admin executable: %w", err)
}
manifestPath := filepath.Join(stage, "release.json")
if err := writeManifest(manifestPath, manifest); err != nil {
return err
}
if err := syncDirectory(stage); err != nil {
return err
}
if err := os.MkdirAll(targetDir, 0750); err != nil {
return fmt.Errorf("create release target: %w", err)
}
return replacePair(stage, targetDir, []string{mainName, adminName, "release.json"})
}
var renamePath = os.Rename
func replacePair(stage, targetDir string, names []string) error {
committed := make([]string, 0, len(names))
backups := make(map[string]string, len(names))
rollback := func() {
for index := len(committed) - 1; index >= 0; index-- {
name := committed[index]
target := filepath.Join(targetDir, name)
_ = os.Remove(target)
if backup, ok := backups[name]; ok {
_ = renamePath(backup, target)
}
}
for name, backup := range backups {
if _, err := os.Stat(filepath.Join(targetDir, name)); os.IsNotExist(err) {
_ = renamePath(backup, filepath.Join(targetDir, name))
}
}
}
for _, name := range names {
target := filepath.Join(targetDir, name)
if _, err := os.Stat(target); err == nil {
backup := target + ".previous"
_ = os.Remove(backup)
if err := renamePath(target, backup); err != nil {
rollback()
return fmt.Errorf("backup %s: %w", name, err)
}
backups[name] = backup
} else if !os.IsNotExist(err) {
rollback()
return fmt.Errorf("inspect %s: %w", name, err)
}
if err := renamePath(filepath.Join(stage, name), target); err != nil {
rollback()
return fmt.Errorf("install %s: %w: %w", name, err, ErrUpgradeRollback)
}
committed = append(committed, name)
}
if err := syncDirectory(targetDir); err != nil {
rollback()
return fmt.Errorf("sync release target: %w: %w", err, ErrUpgradeRollback)
}
for _, backup := range backups {
// 备份清理失败不回滚已经持久化的新版本,避免把升级结果置于不一致状态。
_ = os.Remove(backup)
}
return nil
}
func ReadManifest(targetDir string) (Manifest, error) {
data, err := os.ReadFile(filepath.Join(targetDir, "release.json"))
if err != nil {
return Manifest{}, err
}
var manifest Manifest
if err := json.Unmarshal(data, &manifest); err != nil {
return Manifest{}, fmt.Errorf("decode release manifest: %w", err)
}
return manifest, nil
}
func executableNames() (string, string) {
if runtime.GOOS == "windows" {
return "smail.exe", "smail-admin.exe"
}
return "smail", "smail-admin"
}
func validateExecutableSource(path string) error {
info, err := os.Lstat(path)
if err != nil {
return err
}
if info.Mode()&os.ModeSymlink != 0 || !info.Mode().IsRegular() || info.Size() == 0 {
return ErrInvalidPair
}
return nil
}
func copyExecutable(source, target string, mode os.FileMode) error {
input, err := os.Open(source)
if err != nil {
return err
}
defer input.Close()
output, err := os.OpenFile(target, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, mode)
if err != nil {
return err
}
if _, err := io.Copy(output, input); err != nil {
_ = output.Close()
return err
}
if err := output.Sync(); err != nil {
_ = output.Close()
return err
}
return output.Close()
}
func writeManifest(path string, manifest Manifest) error {
data, err := json.MarshalIndent(manifest, "", " ")
if err != nil {
return fmt.Errorf("encode release manifest: %w", err)
}
data = append(data, '\n')
if err := os.WriteFile(path, data, 0640); err != nil {
return fmt.Errorf("write release manifest: %w", err)
}
return nil
}
func syncDirectory(path string) error {
if runtime.GOOS == "windows" {
return nil
}
directory, err := os.Open(path)
if err != nil {
return err
}
defer directory.Close()
return directory.Sync()
}
func known(value string) bool {
return strings.TrimSpace(value) != "" && value != "unknown" && value != "dev"
}
+116
View File
@@ -0,0 +1,116 @@
package release
import (
"errors"
"os"
"path/filepath"
"testing"
"time"
"git.pcux.cn/xuans/Smail/internal/buildinfo"
)
func TestNewManifestRejectsMismatchedPair(t *testing.T) {
mainInfo := buildinfo.Info{Version: "v1", GitHash: "abc", ProtocolVersion: buildinfo.ProtocolVersion}
adminInfo := buildinfo.Info{Version: "v2", GitHash: "abc", ProtocolVersion: buildinfo.ProtocolVersion}
if _, err := NewManifest(Pair{Main: mainInfo, Admin: adminInfo}, time.Now()); !errors.Is(err, ErrInvalidPair) {
t.Fatalf("NewManifest() error = %v", err)
}
}
func TestInstallPairWritesBothExecutablesAndManifest(t *testing.T) {
root := t.TempDir()
mainSource := filepath.Join(root, "main-source")
adminSource := filepath.Join(root, "admin-source")
if err := os.WriteFile(mainSource, []byte("main-v2"), 0600); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(adminSource, []byte("admin-v2"), 0600); err != nil {
t.Fatal(err)
}
mainInfo := buildinfo.Info{Version: "v2", GitHash: "abc", ProtocolVersion: buildinfo.ProtocolVersion}
target := filepath.Join(root, "bin")
if err := InstallPair(mainSource, adminSource, target, Pair{Main: mainInfo, Admin: mainInfo}); err != nil {
t.Fatal(err)
}
mainName, adminName := executableNames()
for _, name := range []string{mainName, adminName, "release.json"} {
if _, err := os.Stat(filepath.Join(target, name)); err != nil {
t.Fatalf("missing installed file %s: %v", name, err)
}
}
manifest, err := ReadManifest(target)
if err != nil {
t.Fatal(err)
}
if manifest.Version != "v2" || manifest.GitHash != "abc" {
t.Fatalf("unexpected manifest: %+v", manifest)
}
}
func TestInstallPairRollsBackWhenSecondTargetCannotBeReplaced(t *testing.T) {
root := t.TempDir()
mainSource := filepath.Join(root, "main-source")
adminSource := filepath.Join(root, "admin-source")
if err := os.WriteFile(mainSource, []byte("main-v2"), 0600); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(adminSource, []byte("admin-v2"), 0600); err != nil {
t.Fatal(err)
}
target := filepath.Join(root, "bin")
if err := os.MkdirAll(target, 0750); err != nil {
t.Fatal(err)
}
mainName, adminName := executableNames()
if err := os.WriteFile(filepath.Join(target, mainName), []byte("main-v1"), 0600); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(filepath.Join(target, adminName), []byte("admin-v1"), 0600); err != nil {
t.Fatal(err)
}
originalRename := renamePath
t.Cleanup(func() { renamePath = originalRename })
renamePath = func(source, destination string) error {
if filepath.Base(source) == adminName && filepath.Dir(destination) == target && filepath.Ext(destination) == filepath.Ext(adminName) {
return errors.New("simulated replacement failure")
}
return originalRename(source, destination)
}
pair := buildinfo.Info{Version: "v2", GitHash: "abc", ProtocolVersion: buildinfo.ProtocolVersion}
if err := InstallPair(mainSource, adminSource, target, Pair{Main: pair, Admin: pair}); err == nil {
t.Fatal("expected replacement failure")
} else if !errors.Is(err, ErrUpgradeRollback) {
t.Fatalf("error = %v, want rollback marker", err)
}
content, err := os.ReadFile(filepath.Join(target, mainName))
if err != nil {
t.Fatal(err)
}
if string(content) != "main-v1" {
t.Fatalf("main executable was not restored: %q", content)
}
adminContent, err := os.ReadFile(filepath.Join(target, adminName))
if err != nil {
t.Fatal(err)
}
if string(adminContent) != "admin-v1" {
t.Fatalf("admin executable was not restored: %q", adminContent)
}
}
func TestValidateManifestRejectsInvalidTimestamp(t *testing.T) {
info := buildinfo.Info{Version: "v1", GitHash: "abc", ProtocolVersion: buildinfo.ProtocolVersion}
manifest := Manifest{Version: "v1", GitHash: "abc", ProtocolVersion: buildinfo.ProtocolVersion, CreatedAt: "not-a-timestamp"}
if err := ValidateManifest(manifest, Pair{Main: info, Admin: info}); !errors.Is(err, ErrInvalidPair) {
t.Fatalf("ValidateManifest() error = %v, want invalid pair", err)
}
}
func TestValidateManifestRejectsProtocolMismatch(t *testing.T) {
info := buildinfo.Info{Version: "v1", GitHash: "abc", ProtocolVersion: buildinfo.ProtocolVersion}
manifest := Manifest{Version: "v1", GitHash: "abc", ProtocolVersion: buildinfo.ProtocolVersion + 1, CreatedAt: time.Now().UTC().Format(time.RFC3339)}
if err := ValidateManifest(manifest, Pair{Main: info, Admin: info}); !errors.Is(err, ErrInvalidPair) {
t.Fatalf("ValidateManifest() error = %v, want invalid pair", err)
}
}