a55319d972
build / build (push) Failing after 2m29s
现象:共享桶部署下网关启动即报 gateway_auditor_key_required,残留过期 审计文件则每次 Execute 报 gateway_exclusive_writer_evidence_unverified; 用户已改为“停目标写入容器→更新→启动”的维护式更新。 根因:Gateway.Ready 强制 Isolation.Verify,main 强制 Ed25519 公钥,等于 把整桶独占证明当作发布前置;这与共享桶、沿用原 AK 的实际部署矛盾。 取舍:删除审计校验与相关 env 依赖,保留 journal、治理 PG 只读 authority、 plan/owner/attempt/epoch 绑定、intent-before-send、单次写与精确版本回滚。 create 仅在精确版本读回且仍为 current 时提交;发现外部 latest 只返回冲突, 不在 confirm 阶段删除(journal create intent 已提交,删除会变成无 delete intent/receipt 的未记账副作用并让 intent 永久 held)。同 key 不自动合并。 证据:真实二进制无审计/残留审计两环境通过;kg-pgtest-writeset 一次性库 + 随机 MinIO 桶跑 14 个网关用例(含共享桶共存写者、同 key 既有对象拒绝、 精确回滚)全过;umask 022 下 make verify 本地必需项全 success。
237 lines
9.4 KiB
Go
237 lines
9.4 KiB
Go
package v071
|
|
|
|
import (
|
|
"context"
|
|
"crypto/rand"
|
|
"encoding/hex"
|
|
"errors"
|
|
"github.com/jackc/pgx/v5"
|
|
"github.com/jackc/pgx/v5/pgxpool"
|
|
"knowledge-governance/internal/governance"
|
|
"knowledge-governance/internal/libraryrelease"
|
|
"knowledge-governance/internal/objectgateway"
|
|
postgresstore "knowledge-governance/internal/platform/postgres"
|
|
"knowledge-governance/internal/platform/postgres/pgtest"
|
|
"net/http/httptest"
|
|
"net/url"
|
|
"os"
|
|
"sync/atomic"
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
type gatewayCountBackend struct {
|
|
objectgateway.Backend
|
|
puts atomic.Int64
|
|
}
|
|
|
|
func (b *gatewayCountBackend) Put(ctx context.Context, key string, body []byte, owner string) (objectgateway.Version, error) {
|
|
b.puts.Add(1)
|
|
return b.Backend.Put(ctx, key, body, owner)
|
|
}
|
|
|
|
func gatewayReadOnlyGovernance(t *testing.T, ctx context.Context, admin *pgxpool.Pool, dsn string) *pgxpool.Pool {
|
|
t.Helper()
|
|
random := make([]byte, 24)
|
|
if _, e := rand.Read(random); e != nil {
|
|
t.Fatal(e)
|
|
}
|
|
suffix := hex.EncodeToString(random)
|
|
role := "kg_gateway_reader_" + suffix[:12]
|
|
// This role is created only in the explicitly disposable fixture cluster.
|
|
if _, e := admin.Exec(ctx, "CREATE ROLE "+pgx.Identifier{role}.Sanitize()+" LOGIN PASSWORD '"+suffix+"'"); e != nil {
|
|
t.Fatal("create isolated reader role failed")
|
|
}
|
|
var schema string
|
|
if admin.QueryRow(ctx, "SELECT current_schema()").Scan(&schema) != nil {
|
|
t.Fatal("fixture schema")
|
|
}
|
|
t.Cleanup(func() {
|
|
cleanup := context.Background()
|
|
if _, e := admin.Exec(cleanup, "DROP OWNED BY "+pgx.Identifier{role}.Sanitize()); e != nil {
|
|
t.Errorf("reader role privilege cleanup failed")
|
|
}
|
|
if _, e := admin.Exec(cleanup, "DROP ROLE "+pgx.Identifier{role}.Sanitize()); e != nil {
|
|
t.Errorf("reader role cleanup failed")
|
|
}
|
|
})
|
|
if _, e := admin.Exec(ctx, "GRANT USAGE ON SCHEMA "+pgx.Identifier{schema}.Sanitize()+" TO "+pgx.Identifier{role}.Sanitize()); e != nil {
|
|
t.Fatal("reader schema grant")
|
|
}
|
|
if _, e := admin.Exec(ctx, "GRANT SELECT ON library_jobs,library_operations,library_attempts,library_versions,jobs TO "+pgx.Identifier{role}.Sanitize()); e != nil {
|
|
t.Fatal("reader table grant")
|
|
}
|
|
parsed, e := url.Parse(dsn)
|
|
if e != nil {
|
|
t.Fatal("fixture DSN")
|
|
}
|
|
parsed.User = url.UserPassword(role, suffix)
|
|
config, e := pgxpool.ParseConfig(parsed.String())
|
|
if e != nil {
|
|
t.Fatal("reader config")
|
|
}
|
|
config.ConnConfig.RuntimeParams["default_transaction_read_only"] = "on"
|
|
pool, e := pgxpool.NewWithConfig(ctx, config)
|
|
if e != nil {
|
|
t.Fatal("reader connect")
|
|
}
|
|
t.Cleanup(pool.Close)
|
|
t.Log("isolated SELECT-only governance role created; exact role cleanup registered:", role)
|
|
return pool
|
|
}
|
|
|
|
// This is real authority/PG/HTTP/storage integration, not the formal worker
|
|
// process test: no grant decorator or control credential is given to the target.
|
|
func TestContractGatewayAuthorityFrozenPlanIsolated(t *testing.T) {
|
|
fx := openWriteSetFixture(t)
|
|
seedTargetData(t, fx)
|
|
ctx := fx.ctx
|
|
dsn := pgtest.IsolatedDatabaseURL(t, os.Getenv("KG_LIBRARY_TEST_DATABASE_URL"))
|
|
governancePool, e := pgxpool.New(ctx, dsn)
|
|
if e != nil {
|
|
t.Fatal("governance pool")
|
|
}
|
|
t.Cleanup(governancePool.Close)
|
|
if e = postgresstore.ApplyMigrations(ctx, governancePool); e != nil {
|
|
t.Fatal(e)
|
|
}
|
|
if _, e = governancePool.Exec(ctx, objectgateway.Schema); e != nil {
|
|
t.Fatal(e)
|
|
}
|
|
reader := gatewayReadOnlyGovernance(t, ctx, governancePool, dsn)
|
|
const jobID = "gateway-authority-job"
|
|
const targetID = "gateway-authority-target"
|
|
store := postgresstore.NewStore(governancePool).WithLibraryTarget(targetID)
|
|
snapshot := sealSourceSnapshot(t, fx, nil)
|
|
now := time.Now().UTC()
|
|
op := governance.LibraryOperation{ID: "gateway-authority-operation", Scope: "internal", Kind: governance.LibraryJobSync, TargetSnapshotID: snapshot, RequestDigest: "gateway-authority-params", OperationKey: "gateway-authority-key", CreatedAt: now}
|
|
if _, _, e = store.EnsureLibraryOperation(ctx, op); e != nil {
|
|
t.Fatal(e)
|
|
}
|
|
if _, _, e = store.CreateLibraryJob(ctx, governance.LibraryJob{ID: jobID, Scope: "internal", Kind: governance.LibraryJobSync, OperationID: op.ID, IdempotencyKey: jobID, RequestDigest: op.RequestDigest, TargetSnapshotID: snapshot}, governance.SyncStages(), now); e != nil {
|
|
t.Fatal(e)
|
|
}
|
|
attempt, e := store.BeginLibraryAttempt(ctx, jobID, "worker-first", time.Hour, now)
|
|
if e != nil {
|
|
t.Fatal(e)
|
|
}
|
|
if _, e = governancePool.Exec(ctx, "UPDATE library_jobs SET state='running' WHERE id=$1", jobID); e != nil {
|
|
t.Fatal(e)
|
|
}
|
|
authority := &GatewayGovernanceAuthority{Pool: reader, ArchiveRoot: fx.archiveRoot, TargetID: targetID, Provider: "minio", Bucket: fx.bucket}
|
|
if e = authority.Ready(ctx); e != nil {
|
|
t.Fatal(e)
|
|
}
|
|
privileged := *authority
|
|
privileged.Pool = governancePool
|
|
if privileged.Ready(ctx) == nil {
|
|
t.Fatal("privileged controller reader accepted")
|
|
}
|
|
backend := &gatewayCountBackend{Backend: &objectgateway.S3Backend{Client: fx.objects.s3.client, Bucket: fx.bucket, MaxBytes: 1 << 20}}
|
|
gateway := &objectgateway.Gateway{Pool: governancePool, Scope: fx.bucket, Backend: backend, Authority: authority, MaxBytes: 1 << 20}
|
|
data := objectgateway.Digest([]byte("authority-data"))
|
|
server := httptest.NewServer(objectgateway.HTTPServer{Gateway: gateway, DataToken: data, ControlToken: objectgateway.Digest([]byte("authority-control"))})
|
|
defer server.Close()
|
|
client, e := objectgateway.NewClient(server.URL, data, fx.bucket)
|
|
if e != nil {
|
|
t.Fatal(e)
|
|
}
|
|
claim := objectgateway.Claim{JobID: jobID, OperationID: op.ID, AttemptEpoch: int64(attempt.Epoch), Owner: attempt.Owner}
|
|
objects := &GatewayObjectStore{Client: client, Provider: "minio", Bucket: fx.bucket, Automatic: true, Claim: claim}
|
|
target := fx.target(t)
|
|
target.config.Objects = objects
|
|
current, e := target.Current(ctx)
|
|
if e != nil {
|
|
t.Fatal(e)
|
|
}
|
|
backup, e := fx.backups(t, target).Prepare(ctx, snapshot, current)
|
|
if e != nil {
|
|
t.Fatal(e)
|
|
}
|
|
set, e := target.PlanWriteSet(ctx, libraryrelease.WriteSetPlan{JobID: jobID, Target: "internal", BackupSnapshotID: backup.SnapshotID, TargetSnapshotID: snapshot, Universe: backup.Universe})
|
|
if e != nil {
|
|
t.Fatal(e)
|
|
}
|
|
claim.PlanDigest = set.Digest
|
|
before := universeDump(t, fx.pool)
|
|
if e = target.Apply(ctx, libraryrelease.StageDatabase, snapshot); e == nil {
|
|
t.Fatal("unanchored plan permitted first PG write")
|
|
}
|
|
if diff := diffUniverse(before, universeDump(t, fx.pool)); diff != "" {
|
|
t.Fatal("unanchored apply mutated PG", diff)
|
|
}
|
|
if e = store.RecordLibraryVersion(ctx, governance.LibraryVersion{ID: governance.LibraryVersionEventID(governance.LibraryVersionProductionPrebackup, "internal", backup.SnapshotID, op.ID), Scope: "internal", Kind: governance.LibraryVersionProductionPrebackup, SnapshotID: backup.SnapshotID, SourceJobID: jobID, OperationID: op.ID, AttemptEpoch: attempt.Epoch, AttemptOwner: attempt.Owner, CreatedAt: now, Evidence: map[string]any{"job": jobID, "backup_snapshot": backup.SnapshotID, "backup_bytes": backup.Bytes, "writeset_digest": set.Digest, "writeset_target_snapshot": snapshot}}); e != nil {
|
|
t.Fatal(e)
|
|
}
|
|
for _, bad := range []objectgateway.Claim{{JobID: jobID, OperationID: op.ID, AttemptEpoch: claim.AttemptEpoch, Owner: "other-worker", PlanDigest: set.Digest}, {JobID: jobID, OperationID: op.ID, AttemptEpoch: claim.AttemptEpoch, Owner: claim.Owner, PlanDigest: objectgateway.Digest([]byte("replacement"))}} {
|
|
if _, e = client.Acquire(ctx, bad); e == nil {
|
|
t.Fatal("untrusted claim admitted")
|
|
}
|
|
}
|
|
if e = target.Apply(ctx, libraryrelease.StageDatabase, snapshot); e != nil {
|
|
t.Fatal(e)
|
|
}
|
|
if e = target.Apply(ctx, libraryrelease.StageResources, snapshot); e != nil {
|
|
t.Fatal(e)
|
|
}
|
|
count := backend.puts.Load()
|
|
if count == 0 {
|
|
t.Fatal("no actual object send")
|
|
}
|
|
firstRequests := objects.requests
|
|
if e = store.FinishLibraryAttempt(ctx, attempt, governance.LibraryAttemptFailed, "isolated takeover", time.Now().UTC()); e != nil {
|
|
t.Fatal(e)
|
|
}
|
|
next, e := store.BeginLibraryAttempt(ctx, jobID, "worker-second", time.Hour, time.Now().UTC())
|
|
if e != nil {
|
|
t.Fatal(e)
|
|
}
|
|
nextClaim := claim
|
|
nextClaim.AttemptEpoch = int64(next.Epoch)
|
|
nextClaim.Owner = next.Owner
|
|
nextObjects := &GatewayObjectStore{Client: client, Provider: "minio", Bucket: fx.bucket, Automatic: true, Claim: nextClaim}
|
|
nextTarget := fx.target(t)
|
|
nextTarget.config.Objects = nextObjects
|
|
if e = nextTarget.AdoptWriteSet(set); e != nil {
|
|
t.Fatal(e)
|
|
}
|
|
if e = nextObjects.EnsureObjectGrant(ctx); e != nil {
|
|
t.Fatal(e)
|
|
}
|
|
for key, original := range firstRequests {
|
|
if nextObjects.requests[key] != original {
|
|
t.Fatal("send identity replaced during new epoch", key)
|
|
}
|
|
}
|
|
if nextObjects.authorization.Epoch <= objects.authorization.Epoch {
|
|
t.Fatal("authorization did not advance")
|
|
}
|
|
if _, e = client.Acquire(ctx, claim); !errors.Is(e, objectgateway.ErrEpoch) {
|
|
t.Fatal("old active owner admitted", e)
|
|
}
|
|
if e = nextTarget.Apply(ctx, libraryrelease.StageResources, snapshot); e != nil {
|
|
t.Fatal(e)
|
|
}
|
|
if backend.puts.Load() != count {
|
|
t.Fatal("resumed object send duplicated")
|
|
}
|
|
for _, obj := range set.Objects {
|
|
if obj.Existing {
|
|
continue
|
|
}
|
|
locator := obj.Locator
|
|
observation, e := nextObjects.ObserveObject(ctx, obj.Provider, locator)
|
|
if e != nil {
|
|
t.Fatal(e)
|
|
}
|
|
if e = nextObjects.RemoveObject(ctx, obj.Provider, locator, observation); e != nil {
|
|
t.Fatal(e)
|
|
}
|
|
versions, e := backend.List(ctx, obj.Key)
|
|
if e != nil || len(versions) != 0 {
|
|
t.Fatal("created object version residue", e)
|
|
}
|
|
}
|
|
t.Logf("real readonly governance authority -> data-only HTTP acquisition -> PG/MinIO; first-PG anchor denial, new epoch unchanged send identity, PUTs=%d, original version exact cleanup", count)
|
|
}
|