381 lines
15 KiB
Go
381 lines
15 KiB
Go
package mysql
|
||
|
||
import (
|
||
"context"
|
||
"database/sql"
|
||
"os"
|
||
"path/filepath"
|
||
"sync"
|
||
"testing"
|
||
"time"
|
||
|
||
"git.yuntuo.hk/k2safe/orbit/internal/fault"
|
||
"git.yuntuo.hk/k2safe/orbit/internal/retention"
|
||
core "git.yuntuo.hk/k2safe/orbit/model"
|
||
"git.yuntuo.hk/k2safe/orbit/platform/auth"
|
||
)
|
||
|
||
func archiveFixture(t *testing.T, payloadBytes ...int) (context.Context, *sql.DB, *RetentionPolicyStore, auth.Token, core.ID) {
|
||
t.Helper()
|
||
dsn := os.Getenv("ORBIT_TEST_MYSQL_DSN")
|
||
if dsn == "" {
|
||
t.Skip("requires disposable MySQL")
|
||
}
|
||
ctx, cancel := context.WithTimeout(context.Background(), 90*time.Second)
|
||
t.Cleanup(cancel)
|
||
db, err := Open(ctx, dsn, 12, 4)
|
||
if err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
t.Cleanup(func() { db.Close() })
|
||
if err = Migrate(ctx, db); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
app := testID(t)
|
||
username := "archive-" + string(app)
|
||
var boot BootstrapResult
|
||
if err = Bootstrap(ctx, db, BootstrapInput{Application: string(app), Namespace: "archive", Environment: "test", Queue: "archive", ConsoleUsername: username, ConsolePassword: "test-only-strong-password-123"}, func(b BootstrapResult) error { boot = b; return nil }); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
login, err := NewConsoleAuthStore(db).Login(ctx, username, "test-only-strong-password-123", "archive-test", "127.0.0.1")
|
||
if err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
token, err := auth.Parse(login.Token)
|
||
if err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
store := NewRetentionPolicyStore(db)
|
||
_, err = store.UpdateRetentionPolicy(ctx, token, "initial", retention.UpdateInput{Enabled: true, IdempotencyDays: 90, TaskHistoryDays: 1, WorkflowHistoryDays: 1, EventLogDays: 1, DeliveryHistoryDays: 1, InboxHistoryDays: 1, AuditLogDays: 1, Reason: "isolated archive test"})
|
||
if err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
// 三条过期审计作为真实归档数据，分两批读取，避免凭空伪造任务生命周期。
|
||
size := 0
|
||
if len(payloadBytes) > 0 {
|
||
size = payloadBytes[0]
|
||
}
|
||
for i := 0; i < 3; i++ {
|
||
_, err = db.ExecContext(ctx, "INSERT INTO orbit_audit_events(namespace_id,id,operation_id,actor_id,action,resource_kind,resource_id,reason,`before`,created_at) VALUES(?,?,?,'test','fixture','archive_job',?,'source retained',JSON_OBJECT('fixture',REPEAT('x',?)),TIMESTAMPADD(DAY,-3,UTC_TIMESTAMP(6)))", boot.NamespaceID, testID(t), testID(t), testID(t), size)
|
||
if err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
}
|
||
return ctx, db, store, token, testID(t)
|
||
}
|
||
func archivePlanInput() retention.PlanInput {
|
||
return retention.PlanInput{PolicyRevision: 1, Enabled: true, IntervalSeconds: 3600, BatchSize: 2, MaxBytes: 4 << 20, Reason: "enable isolated schedule"}
|
||
}
|
||
func mustArchiveJobs(t *testing.T, ctx context.Context, s *RetentionPolicyStore, token auth.Token) []retention.ManagedJob {
|
||
t.Helper()
|
||
p, err := s.ListArchiveJobs(ctx, token, "")
|
||
if err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
return p.Items
|
||
}
|
||
|
||
func TestIntegrationArchiveSchedulerRaceResumeAndFencing(t *testing.T) {
|
||
ctx, db, s, token, volume := archiveFixture(t)
|
||
in := archivePlanInput()
|
||
p, err := s.SaveArchivePlan(ctx, token, "plan", "audit", volume, in)
|
||
if err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
replay, err := s.SaveArchivePlan(ctx, token, "plan", "audit", volume, in)
|
||
if err != nil || replay.Revision != p.Revision {
|
||
t.Fatal("plan replay", err)
|
||
}
|
||
if _, err = s.SaveArchivePlan(ctx, token, "stale", "audit", volume, in); fault.Code(err) != "STATE_CONFLICT" {
|
||
t.Fatal("stale plan accepted", err)
|
||
}
|
||
var wg sync.WaitGroup
|
||
errs := make(chan error, 8)
|
||
for i := 0; i < 8; i++ {
|
||
wg.Add(1)
|
||
go func() { defer wg.Done(); errs <- NewRetentionPolicyStore(db).ScheduleArchive(ctx, volume) }()
|
||
}
|
||
wg.Wait()
|
||
close(errs)
|
||
for err := range errs {
|
||
if err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
}
|
||
jobs := mustArchiveJobs(t, ctx, s, token)
|
||
if len(jobs) != 1 || jobs[0].PlanRevision != p.Revision {
|
||
t.Fatalf("duplicate schedules: %+v", jobs)
|
||
}
|
||
claims := make(chan *retention.ManagedJob, 8)
|
||
errs = make(chan error, 8)
|
||
for i := 0; i < 8; i++ {
|
||
wg.Add(1)
|
||
go func() { defer wg.Done(); j, e := s.ClaimArchive(ctx, volume); claims <- j; errs <- e }()
|
||
}
|
||
wg.Wait()
|
||
close(claims)
|
||
close(errs)
|
||
for e := range errs {
|
||
if e != nil {
|
||
t.Fatal(e)
|
||
}
|
||
}
|
||
var old *retention.ManagedJob
|
||
for j := range claims {
|
||
if j != nil {
|
||
if old != nil {
|
||
t.Fatal("duplicate claim")
|
||
}
|
||
old = j
|
||
}
|
||
}
|
||
if old == nil {
|
||
t.Fatal("no claim")
|
||
}
|
||
root := filepath.Join(t.TempDir(), "volume")
|
||
runtime := &retention.ArchiveRuntime{Directory: root, StorageID: volume, MaxBytes: 16 << 20, Store: s}
|
||
if err = runtime.Init(); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
dir := filepath.Join(root, string(token.NamespaceID)+"-"+string(old.ID))
|
||
spec := retention.JobSpec{NamespaceID: token.NamespaceID, Kind: "audit", PolicyRevision: 1, BatchSize: 2}
|
||
first, err := retention.RunArchive(ctx, dir, spec, retention.JobOptions{JobID: old.ID, MaxBatches: 1, MaxBytes: 4 << 20}, func(ctx context.Context, id core.ID, in retention.ArchiveInput) (retention.ArchiveSnapshot, error) {
|
||
return s.ExportRetentionForJob(ctx, token.NamespaceID, id, in)
|
||
})
|
||
if err != nil || first.Batches != 1 || first.Roots != 2 || first.Completed {
|
||
t.Fatal("first batch", first, err)
|
||
}
|
||
// 模拟文件已落盘但数据库确认尚未提交；租约到期后另一节点恢复同一作业。
|
||
if _, err = db.ExecContext(ctx, `UPDATE orbit_archive_jobs SET lease_until=TIMESTAMPADD(SECOND,-1,UTC_TIMESTAMP(6)) WHERE namespace_id=? AND id=?`, token.NamespaceID, old.ID); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
newer, err := s.ClaimArchive(ctx, volume)
|
||
if err != nil || newer == nil || newer.LeaseID == old.LeaseID {
|
||
t.Fatal("reclaim", err)
|
||
}
|
||
if err = s.FinishArchive(ctx, *old, first, ""); fault.Code(err) != "STATE_CONFLICT" {
|
||
t.Fatal("stale claimant advanced", err)
|
||
}
|
||
if err = s.FinishArchive(ctx, *newer, first, ""); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
if err = runtime.Tick(ctx); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
jobs = mustArchiveJobs(t, ctx, s, token)
|
||
if len(jobs) != 1 || jobs[0].ID != old.ID || jobs[0].State != "SUCCEEDED" || jobs[0].Roots != 3 || jobs[0].Batches != 2 {
|
||
t.Fatalf("resume result: %+v", jobs)
|
||
}
|
||
verified, err := retention.VerifyArchive(ctx, dir)
|
||
if err != nil || verified.LastSHA256 != jobs[0].LastSHA256 || !verified.Completed {
|
||
t.Fatal("offline mismatch", err)
|
||
}
|
||
if err = runtime.Tick(ctx); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
if len(mustArchiveJobs(t, ctx, s, token)) != 1 {
|
||
t.Fatal("replayed due slot")
|
||
}
|
||
var sources, fks int
|
||
if err = db.QueryRowContext(ctx, `SELECT COUNT(*) FROM orbit_audit_events WHERE namespace_id=? AND action='fixture'`, token.NamespaceID).Scan(&sources); err != nil || sources != 3 {
|
||
t.Fatal("source deleted", err)
|
||
}
|
||
if err = db.QueryRowContext(ctx, `SELECT COUNT(*) FROM information_schema.REFERENTIAL_CONSTRAINTS WHERE CONSTRAINT_SCHEMA=DATABASE()`).Scan(&fks); err != nil || fks != 0 {
|
||
t.Fatal("foreign keys introduced", err)
|
||
}
|
||
t.Log("8 schedulers -> 1 job; 8 claimants -> 1 lease; durable file prefix survives missing DB confirmation; old lease rejected; 3 source rows retained")
|
||
}
|
||
|
||
func TestIntegrationArchiveFailureRetryPolicyAndScope(t *testing.T) {
|
||
ctx, db, s, token, volume := archiveFixture(t)
|
||
in := archivePlanInput()
|
||
if _, err := s.SaveArchivePlan(ctx, token, "plan", "audit", volume, in); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
runtime := &retention.ArchiveRuntime{Directory: filepath.Join(t.TempDir(), "volume"), StorageID: volume, MaxBytes: 16 << 20, Store: s}
|
||
if err := runtime.Init(); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
if err := runtime.Tick(ctx); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
j := mustArchiveJobs(t, ctx, s, token)[0]
|
||
if j.State != "PENDING" || j.Batches != 1 {
|
||
t.Fatalf("first chunk %+v", j)
|
||
}
|
||
dir := filepath.Join(runtime.Directory, string(token.NamespaceID)+"-"+string(j.ID))
|
||
file := filepath.Join(dir, "batch-000001.json")
|
||
saved, err := os.ReadFile(file)
|
||
if err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
if err = os.WriteFile(file, []byte("broken"), 0600); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
if err = runtime.Tick(ctx); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
failed := mustArchiveJobs(t, ctx, s, token)[0]
|
||
if failed.State != "FAILED" || failed.ErrorCode != "FILE_CHECK_FAILED" || failed.LastSHA256 != j.LastSHA256 || failed.Batches != 1 {
|
||
t.Fatalf("failed checkpoint %+v", failed)
|
||
}
|
||
// 失败占位阻止到期计划另建作业。
|
||
if _, err = db.ExecContext(ctx, `UPDATE orbit_archive_plans SET next_run_at=TIMESTAMPADD(DAY,-2,UTC_TIMESTAMP(6)) WHERE namespace_id=?`, token.NamespaceID); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
if err = runtime.Tick(ctx); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
if len(mustArchiveJobs(t, ctx, s, token)) != 1 {
|
||
t.Fatal("failure spawned another job")
|
||
}
|
||
action := retention.JobActionInput{ExpectedRevision: failed.Revision, Action: "retry", MaxBytes: failed.MaxBytes, Reason: "restored exact original archive file"}
|
||
if err = os.WriteFile(file, saved, 0600); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
retried, err := s.ActArchiveJob(ctx, token, j.ID, "retry-original", action)
|
||
if err != nil || retried.ID != j.ID || retried.State != "PENDING" {
|
||
t.Fatal("retry", err)
|
||
}
|
||
if _, err = s.ActArchiveJob(ctx, token, j.ID, "retry-original", action); err != nil {
|
||
t.Fatal("retry replay", err)
|
||
}
|
||
if _, err = s.ActArchiveJob(ctx, token, j.ID, "retry-stale", action); fault.Code(err) != "STATE_CONFLICT" {
|
||
t.Fatal("stale retry", err)
|
||
}
|
||
// 改策略不允许旧作业静默采用新保留窗口。
|
||
_, err = s.UpdateRetentionPolicy(ctx, token, "changed-policy", retention.UpdateInput{ExpectedRevision: 1, Enabled: true, IdempotencyDays: 90, TaskHistoryDays: 2, WorkflowHistoryDays: 2, EventLogDays: 2, DeliveryHistoryDays: 2, InboxHistoryDays: 2, AuditLogDays: 2, Reason: "new reviewed retention policy"})
|
||
if err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
if err = runtime.Tick(ctx); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
failed = mustArchiveJobs(t, ctx, s, token)[0]
|
||
if failed.State != "FAILED" || failed.ErrorCode != "POLICY_CHANGED" {
|
||
t.Fatalf("changed policy %+v", failed)
|
||
}
|
||
action = retention.JobActionInput{ExpectedRevision: failed.Revision, Action: "abandon", MaxBytes: failed.MaxBytes, Reason: "close old version; preserve files"}
|
||
closed, err := s.ActArchiveJob(ctx, token, j.ID, "close", action)
|
||
if err != nil || closed.State != "ABANDONED" {
|
||
t.Fatal("close", err)
|
||
}
|
||
if err = runtime.Tick(ctx); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
if len(mustArchiveJobs(t, ctx, s, token)) != 1 {
|
||
t.Fatal("stale plan triggered")
|
||
}
|
||
// 无会话和异命名空间不能读取或处理作业。
|
||
other := token
|
||
other.NamespaceID = testID(t)
|
||
if _, err = s.ListArchiveJobs(ctx, other, ""); err == nil {
|
||
t.Fatal("cross namespace read")
|
||
}
|
||
if _, err = s.ActArchiveJob(ctx, other, j.ID, "cross", action); err == nil {
|
||
t.Fatal("cross namespace action")
|
||
}
|
||
// 更新计划策略后，过期的多次周期只生成一个新作业。
|
||
in.ExpectedRevision = 1
|
||
in.PolicyRevision = 2
|
||
if _, err = s.SaveArchivePlan(ctx, token, "plan-new-policy", "audit", volume, in); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
if err = runtime.Tick(ctx); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
jobs := mustArchiveJobs(t, ctx, s, token)
|
||
if len(jobs) != 2 || jobs[0].PolicyRevision != 2 {
|
||
t.Fatalf("new policy job %+v", jobs)
|
||
}
|
||
// 暂停计划不影响已有作业结清，但不再生成后续作业。
|
||
in.ExpectedRevision = 2
|
||
in.Enabled = false
|
||
if _, err = s.SaveArchivePlan(ctx, token, "pause-plan", "audit", volume, in); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
if err = runtime.Tick(ctx); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
jobs = mustArchiveJobs(t, ctx, s, token)
|
||
if len(jobs) != 2 || jobs[0].State != "SUCCEEDED" {
|
||
t.Fatalf("pause blocked in-flight %+v", jobs)
|
||
}
|
||
var retries int
|
||
if err = db.QueryRowContext(ctx, `SELECT COUNT(*) FROM orbit_audit_events WHERE namespace_id=? AND action='retention.job.retry'`, token.NamespaceID).Scan(&retries); err != nil || retries != 1 {
|
||
t.Fatal("retry audit duplicated", err)
|
||
}
|
||
t.Log("corrupt file fails closed; restored file retries same identity exactly once; policy change blocks old job; audited close releases slot; disabled plan lets current job settle")
|
||
}
|
||
|
||
func TestIntegrationArchiveBudgetsResumeAndPagination(t *testing.T) {
|
||
ctx, db, s, token, volume := archiveFixture(t, 600000)
|
||
in := archivePlanInput()
|
||
in.MaxBytes = 1 << 20
|
||
if _, err := s.SaveArchivePlan(ctx, token, "plan", "audit", volume, in); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
runtime := &retention.ArchiveRuntime{Directory: filepath.Join(t.TempDir(), "volume"), StorageID: volume, MaxBytes: 8 << 20, Store: s}
|
||
if err := runtime.Init(); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
if err := runtime.Tick(ctx); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
failed := mustArchiveJobs(t, ctx, s, token)[0]
|
||
if failed.State != "FAILED" || failed.ErrorCode != "STORAGE_LIMIT" {
|
||
t.Fatalf("budget was ignored %+v", failed)
|
||
}
|
||
_, err := s.ActArchiveJob(ctx, token, failed.ID, "raise-budget", retention.JobActionInput{ExpectedRevision: failed.Revision, Action: "retry", MaxBytes: 4 << 20, Reason: "reviewed file budget"})
|
||
if err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
for i := 0; i < 2; i++ {
|
||
if err = runtime.Tick(ctx); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
}
|
||
complete := mustArchiveJobs(t, ctx, s, token)[0]
|
||
if complete.ID != failed.ID || complete.State != "SUCCEEDED" || complete.Roots != 3 || complete.Bytes <= 1<<20 || complete.Bytes > 4<<20 {
|
||
t.Fatalf("budget retry %+v", complete)
|
||
}
|
||
// 全卷预算独立于单作业预算：即使单作业允许4MiB，也不能突破剩余卷容量。
|
||
if _, err = db.ExecContext(ctx, `UPDATE orbit_archive_plans SET next_run_at=TIMESTAMPADD(DAY,-1,UTC_TIMESTAMP(6)) WHERE namespace_id=?`, token.NamespaceID); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
runtime.MaxBytes = complete.Bytes + 100
|
||
if err = runtime.Tick(ctx); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
jobs := mustArchiveJobs(t, ctx, s, token)
|
||
if len(jobs) != 2 || jobs[0].State != "FAILED" || jobs[0].ErrorCode != "STORAGE_LIMIT" || jobs[0].Bytes != 0 {
|
||
t.Fatalf("volume budget %+v", jobs)
|
||
}
|
||
// 分页使用真实时间+ID顺序，数量限制由SQL完成；无效/异命名空间位置拒绝。
|
||
for i := 0; i < 24; i++ {
|
||
_, err = db.ExecContext(ctx, `INSERT INTO orbit_archive_jobs(namespace_id,id,kind,plan_revision,policy_revision,storage_id,batch_size,max_bytes,state,created_at) VALUES(?,?,'audit',1,1,?,2,1048576,'ABANDONED',TIMESTAMPADD(DAY,-2,UTC_TIMESTAMP(6)))`, token.NamespaceID, testID(t), volume)
|
||
if err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
}
|
||
first, err := s.ListArchiveJobs(ctx, token, "")
|
||
if err != nil || len(first.Items) != 20 || first.NextBefore == "" {
|
||
t.Fatal("first page", err)
|
||
}
|
||
second, err := s.ListArchiveJobs(ctx, token, first.NextBefore)
|
||
if err != nil || len(second.Items) != 6 || second.NextBefore != "" {
|
||
t.Fatal("second page", err)
|
||
}
|
||
seen := map[core.ID]bool{}
|
||
for _, j := range append(first.Items, second.Items...) {
|
||
if seen[j.ID] {
|
||
t.Fatal("duplicate page item")
|
||
}
|
||
seen[j.ID] = true
|
||
}
|
||
if _, err = s.ListArchiveJobs(ctx, token, string(testID(t))); fault.Code(err) != "NOT_FOUND" {
|
||
t.Fatal("unknown page position", err)
|
||
}
|
||
t.Log("single-job byte budget stops and resumes same ID; volume budget blocks extra output; 26 jobs paginate 20+6 without duplicates")
|
||
}
|