yms-daemon/internal/backendupdate/updater_test.go

package backendupdate

import (
	"archive/zip"
	"context"
	"crypto/sha256"
	"encoding/hex"
	"encoding/json"
	"io"
	"log/slog"
	"os"
	"path/filepath"
	"testing"

	"yms-daemon/internal/deploymentconfig"
	"yms-daemon/internal/hostnginx"
	"yms-daemon/internal/nativebackendexecutor"
	"yms-daemon/internal/systemd"
	"yms-daemon/internal/transaction"
	"yms-daemon/internal/updatepackage"
)

// TestUpdaterMigratesLegacyBackendAndCommits 验证通过 repack 包更新时，能把仍在运行的旧版后端单元
// （ymsback.service）迁移到模板单元并完成提交。
func TestUpdaterMigratesLegacyBackendAndCommits(t *testing.T) {
	testUpdaterMigratesLegacyBackendAndCommits(t, false)
}

// TestUpdaterCommitsDirectNativeJAR 验证直接安装 native JAR 时能完成提交，
// 并进一步验证重启事务的创建、恢复与槽位旋转。
func TestUpdaterCommitsDirectNativeJAR(t *testing.T) {
	testUpdaterMigratesLegacyBackendAndCommits(t, true)
}

// testUpdaterMigratesLegacyBackendAndCommits 上述两个测试共用的驱动函数。
// 当 direct 为 false 时走 repack 更新路径，为 true 时走直接 JAR 安装路径，
// 并额外验证重启事务的创建、恢复以及槽位旋转行为。
func testUpdaterMigratesLegacyBackendAndCommits(t *testing.T, direct bool) {
	t.Helper()
	ctx := context.Background()
	root := t.TempDir()
	store, err := transaction.OpenStore(ctx, filepath.Join(root, "transactions.db"))
	if err != nil {
		t.Fatalf("open transaction store: %v", err)
	}
	defer store.Close()
	coordinator, err := transaction.NewCoordinator(store, slog.New(slog.NewTextHandler(io.Discard, nil)))
	if err != nil {
		t.Fatalf("create transaction coordinator: %v", err)
	}

	releaseDir := filepath.Join(root, "releases")
	activeJAR := filepath.Join(root, "lib", "glory-soft-yms.jar")
	if err := os.MkdirAll(filepath.Dir(activeJAR), 0o750); err != nil {
		t.Fatalf("create backend lib directory: %v", err)
	}
	if err := os.WriteFile(activeJAR, []byte("legacy backend JAR"), 0o644); err != nil {
		t.Fatalf("write legacy backend JAR: %v", err)
	}
	config := deploymentconfig.Config{Backend: deploymentconfig.Backend{
		Type:       deploymentconfig.BackendTypeNative,
		ReleaseDir: releaseDir,
		ActiveJAR:  activeJAR,
		Slot: deploymentconfig.BackendSlots{
			Port8080: deploymentconfig.BackendSlot{
				Unit:           "yms-backend@8080.service",
				JAR:            filepath.Join(root, "lib", "glory-soft-yms-8080.jar"),
				HealthEndpoint: "http://127.0.0.1:8080/yms/actuator/health",
			},
			Port8081: deploymentconfig.BackendSlot{
				Unit:           "yms-backend@8081.service",
				JAR:            filepath.Join(root, "lib", "glory-soft-yms-8081.jar"),
				HealthEndpoint: "http://127.0.0.1:8081/yms/actuator/health",
			},
		},
	}}
	units := &updateUnitManager{units: map[string]systemd.Unit{
		"yms-backend@8080.service": {Name: "yms-backend@8080.service", LoadState: "loaded", ActiveState: "inactive"},
		"yms-backend@8081.service": {Name: "yms-backend@8081.service", LoadState: "loaded", ActiveState: "inactive"},
		legacyUnit8080:             {Name: legacyUnit8080, LoadState: "loaded", ActiveState: "failed"},
		legacyUnit8081:             {Name: legacyUnit8081, LoadState: "loaded", ActiveState: "activating"},
	}}
	gateway := &memoryGateway{snapshot: hostnginx.Snapshot{Content: []byte(serverConfiguration8081), ActivePort: 8081}}
	executor := &preparingExecutor{store: store, releaseDir: releaseDir, units: units}
	updater := &Updater{
		config:      config,
		workRoot:    filepath.Join(root, "work"),
		store:       store,
		coordinator: coordinator,
		units:       units,
		gateway:     gateway,
		executor:    executor,
		logger:      slog.New(slog.NewTextHandler(io.Discard, nil)),
		drain:       0,
	}
	var record transaction.Transaction
	var installedPath string
	var progress []Progress
	report := func(event Progress) {
		progress = append(progress, event)
	}
	if direct {
		jarPath := writeDirectBackendJAR(t, []byte("new backend JAR"))
		jar, err := updatepackage.OpenDirectNativeJAR(jarPath)
		if err != nil {
			t.Fatalf("inspect direct native backend JAR: %v", err)
		}
		installedPath = filepath.Join(releaseDir, "direct", jar.SHA256[:12], jar.FileName)
		record, err = updater.UpdateNativeJAR(ctx, jarPath, report)
	} else {
		packagePath := writeNativeBackendPackage(t, []byte("new backend JAR"))
		installedPath = filepath.Join(releaseDir, "glory-soft-yms-test.jar")
		record, err = updater.UpdateRepack(ctx, packagePath, report)
	}
	if err != nil {
		t.Fatalf("update native backend: %v", err)
	}
	if record.State != transaction.StateCommitted || gateway.snapshot.ActivePort != 8080 {
		t.Fatalf("unexpected committed update: record=%+v gateway=%+v", record, gateway.snapshot)
	}
	if target, err := os.Readlink(activeJAR); err != nil || target != installedPath {
		t.Fatalf("unexpected compatibility link: target=%q installed=%q err=%v", target, installedPath, err)
	}
	if units.units[legacyUnit8081].ActiveState != "failed" || units.stopped != legacyUnit8081 {
		t.Fatalf("legacy backend unit was not stopped: unit=%+v stopped=%s", units.units[legacyUnit8081], units.stopped)
	}
	if len(progress) == 0 || progress[len(progress)-1].State != transaction.StateCommitted {
		t.Fatalf("missing committed update progress: %+v", progress)
	}
	if direct {
		previousTransactionID := record.ID
		restartSource, sourceErr := currentReleaseSource(activeJAR)
		if sourceErr != nil {
			t.Fatalf("resolve restart source: %v", sourceErr)
		}
		restartJAR, sourceErr := updatepackage.OpenDirectNativeJAR(restartSource)
		if sourceErr != nil {
			t.Fatalf("open restart source: %v", sourceErr)
		}
		restartReleasePath, sourceErr := updater.restartReleasePath(restartJAR)
		if sourceErr != nil {
			t.Fatalf("resolve restart release path: %v", sourceErr)
		}
		pendingRestart, _, created, sourceErr := updater.createOrResume(ctx, updateInput{
			IdempotencyKey:   "backend:restart:test-resume",
			InputType:        inputTypeCurrentRelease,
			SourcePath:       restartJAR.Path,
			SourceSHA256:     restartJAR.SHA256,
			ArtifactFileName: restartJAR.FileName,
			ArtifactIdentity: restartJAR.Identity,
			ReleasePath:      restartReleasePath,
			Materialize:      restartJAR.CopyArtifact,
		})
		if sourceErr != nil || !created {
			t.Fatalf("create interrupted restart transaction: record=%+v created=%t err=%v", pendingRestart, created, sourceErr)
		}
		progress = nil
		record, err = updater.Restart(ctx, report)
		if err != nil {
			t.Fatalf("restart native backend: %v", err)
		}
		if record.ID == previousTransactionID || record.ID != pendingRestart.ID || record.State != transaction.StateCommitted {
			t.Fatalf("unexpected resumed restart transaction: previous=%s pending=%s record=%+v", previousTransactionID, pendingRestart.ID, record)
		}
		if gateway.snapshot.ActivePort != 8081 || units.units["yms-backend@8081.service"].ActiveState != "active" || units.units["yms-backend@8080.service"].ActiveState != "failed" {
			t.Fatalf("restart did not rotate native backend slots: gateway=%+v units=%+v", gateway.snapshot, units.units)
		}
		if len(progress) == 0 || progress[len(progress)-1].Message != "Native backend restart committed" {
			t.Fatalf("missing committed restart progress: %+v", progress)
		}
	}
}

// serverConfiguration8081 测试用的 host Nginx 配置片段，其活跃后端端口为 8081。
const serverConfiguration8081 = `http {
    upstream yms-server {
        # yms-update managed upstream begin
        # server 10.11.1.117:8080 max_fails=1 fail_timeout=2s;
        server 10.11.1.117:8081 max_fails=1 fail_timeout=2s;
        # yms-update managed upstream end
    }
}
`

// memoryGateway 网关控制器的测试替身，在内存中保存 host Nginx 快照，
// 记录 Apply 调用次数，并支持在应用前注入失败以模拟切换故障。
type memoryGateway struct {
	snapshot    hostnginx.Snapshot
	applyCount  int
	beforeApply func(hostnginx.Snapshot) error
}

// Read 返回当前保存的网关快照副本。
func (g *memoryGateway) Read() (hostnginx.Snapshot, error) {
	return hostnginx.Snapshot{Content: append([]byte(nil), g.snapshot.Content...), ActivePort: g.snapshot.ActivePort}, nil
}

// Apply 在 beforeApply 钩子通过后，将给定快照保存为当前状态并累计应用次数。
func (g *memoryGateway) Apply(_ context.Context, snapshot hostnginx.Snapshot) error {
	if g.beforeApply != nil {
		if err := g.beforeApply(snapshot); err != nil {
			return err
		}
	}
	g.snapshot = hostnginx.Snapshot{Content: append([]byte(nil), snapshot.Content...), ActivePort: snapshot.ActivePort}
	g.applyCount++
	return nil
}

// updateUnitManager systemd 单元管理器的测试替身，在内存中维护单元状态，
// 并记录最近一次被停止的单元名称。
type updateUnitManager struct {
	units   map[string]systemd.Unit
	stopped string
}

// Inspect 返回指定名称的单元状态。
func (m *updateUnitManager) Inspect(_ context.Context, name string) (systemd.Unit, error) {
	return m.units[name], nil
}

// Start 将指定单元置为 active。
func (m *updateUnitManager) Start(_ context.Context, name string) error {
	unit := m.units[name]
	unit.ActiveState = "active"
	m.units[name] = unit
	return nil
}

// Stop 将指定单元置为 failed 并记录其名称。
func (m *updateUnitManager) Stop(_ context.Context, name string) error {
	unit := m.units[name]
	unit.ActiveState = "failed"
	m.units[name] = unit
	m.stopped = name
	return nil
}

// preparingExecutor 原生后端执行器的测试替身：它把制品写入发布目录、
// 建立槽位软链接、启动目标单元并推进事务状态，模拟执行器在真实环境中的工作。
type preparingExecutor struct {
	store      *transaction.Store
	releaseDir string
	units      *updateUnitManager
}

// Run 将请求中的制品落盘到发布目录，创建槽位软链接，启动目标单元，
// 并把事务依次推进到 Starting 状态，用于驱动后续切换与提交逻辑。
func (e *preparingExecutor) Run(ctx context.Context, transactionID string, request nativebackendexecutor.Request) error {
	if err := os.MkdirAll(e.releaseDir, 0o750); err != nil {
		return err
	}
	content, err := os.ReadFile(request.ArtifactPath)
	if err != nil {
		return err
	}
	installedPath := filepath.Join(e.releaseDir, request.ReleasePath)
	if err := os.MkdirAll(filepath.Dir(installedPath), 0o750); err != nil {
		return err
	}
	if err := os.WriteFile(installedPath, content, 0o640); err != nil {
		return err
	}
	if err := os.Symlink(installedPath, request.SlotJarPath); err != nil {
		return err
	}
	if err := e.units.Start(ctx, request.UnitName); err != nil {
		return err
	}
	for _, state := range []transaction.State{
		transaction.StateValidating,
		transaction.StatePrepared,
		transaction.StateStarting,
		transaction.StateSwitching,
	} {
		if _, err := e.store.Transition(ctx, transactionID, state, "test transition"); err != nil {
			return err
		}
	}
	return nil
}

// writeNativeBackendPackage 生成一个包含 artifact-selection.json 清单和
// glory-soft-yms-test.jar 制品的 repack ZIP 包，返回其路径。
func writeNativeBackendPackage(t *testing.T, jar []byte) string {
	t.Helper()
	digest := sha256.Sum256(jar)
	manifest := map[string]any{
		"customerCode":        "customer-01",
		"customerDisplayName": "Customer 01",
		"versionId":           "V1.1.8",
		"items":               []string{"deploy-sync.sh"},
		"backendArtifacts": []any{map[string]any{
			"id":           int64(42),
			"versionCode":  "V1.1.8",
			"artifactKind": "BACKEND",
			"type":         "native",
			"selectedType": "native",
			"platform":     nil,
			"fileName":     "glory-soft-yms-test.jar",
			"filePath":     "/archive/glory-soft-yms-test.jar",
			"sha256":       hex.EncodeToString(digest[:]),
			"imageRef":     nil,
		}},
		"frontendArtifacts": []any{},
		"nodeSsrArtifacts":  []any{},
		"remark":            nil,
	}
	manifestContent, err := json.Marshal(manifest)
	if err != nil {
		t.Fatalf("encode artifact selection: %v", err)
	}
	packagePath := filepath.Join(t.TempDir(), "package.zip")
	file, err := os.Create(packagePath)
	if err != nil {
		t.Fatalf("create update package: %v", err)
	}
	writer := zip.NewWriter(file)
	for name, content := range map[string][]byte{
		"artifact-selection.json": manifestContent,
		"glory-soft-yms-test.jar": jar,
	} {
		entry, err := writer.Create(name)
		if err != nil {
			t.Fatalf("create update package entry: %v", err)
		}
		if _, err := entry.Write(content); err != nil {
			t.Fatalf("write update package entry: %v", err)
		}
	}
	if err := writer.Close(); err != nil {
		t.Fatalf("close update package writer: %v", err)
	}
	if err := file.Close(); err != nil {
		t.Fatalf("close update package: %v", err)
	}
	return packagePath
}

// writeDirectBackendJAR 生成一个包含 BOOT-INF/classes/application.properties 的直接 native JAR，
// 返回其路径，供直接安装更新路径使用。
func writeDirectBackendJAR(t *testing.T, content []byte) string {
	t.Helper()
	jarPath := filepath.Join(t.TempDir(), "glory-soft-yms.jar")
	file, err := os.Create(jarPath)
	if err != nil {
		t.Fatalf("create direct backend JAR: %v", err)
	}
	writer := zip.NewWriter(file)
	entry, err := writer.Create("BOOT-INF/classes/application.properties")
	if err != nil {
		t.Fatalf("create direct backend JAR entry: %v", err)
	}
	if _, err := entry.Write(content); err != nil {
		t.Fatalf("write direct backend JAR entry: %v", err)
	}
	if err := writer.Close(); err != nil {
		t.Fatalf("close direct backend JAR writer: %v", err)
	}
	if err := file.Close(); err != nil {
		t.Fatalf("close direct backend JAR: %v", err)
	}
	return jarPath
}