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。
154 lines
5.5 KiB
Go
154 lines
5.5 KiB
Go
package objectgateway
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"testing"
|
|
)
|
|
|
|
type fakeBackend struct {
|
|
byID map[string]Version
|
|
latest Version
|
|
latestExists bool
|
|
latestErr error
|
|
putVersion Version
|
|
putErr error
|
|
putCalls int
|
|
deletes []string
|
|
deleteErr error
|
|
}
|
|
|
|
func (f *fakeBackend) Ready(context.Context) error { return nil }
|
|
func (f *fakeBackend) Observe(_ context.Context, _ string, id string) (Version, bool, error) {
|
|
if id == "" {
|
|
if f.latestErr != nil {
|
|
return Version{}, false, f.latestErr
|
|
}
|
|
return f.latest, f.latestExists, nil
|
|
}
|
|
v, ok := f.byID[id]
|
|
return v, ok, nil
|
|
}
|
|
func (f *fakeBackend) List(context.Context, string) ([]Version, error) { return nil, nil }
|
|
func (f *fakeBackend) Put(context.Context, string, []byte, string) (Version, error) {
|
|
f.putCalls++
|
|
if f.putErr != nil {
|
|
return Version{}, f.putErr
|
|
}
|
|
return f.putVersion, nil
|
|
}
|
|
func (f *fakeBackend) Delete(_ context.Context, _ string, v Version) error {
|
|
if f.deleteErr != nil {
|
|
return f.deleteErr
|
|
}
|
|
f.deletes = append(f.deletes, v.ID)
|
|
delete(f.byID, v.ID)
|
|
return nil
|
|
}
|
|
|
|
func createFixture(t *testing.T) (Request, Version) {
|
|
t.Helper()
|
|
body := []byte("shared bucket object")
|
|
grant := Grant{Epoch: 1, Owner: Digest([]byte("owner")), Plan: Digest([]byte("plan"))}
|
|
r := Request{Grant: grant, Operation: Digest([]byte("operation")), Key: "kb/bound/object-1", Action: "create", SHA256: Digest(body), Bytes: int64(len(body))}
|
|
v := Version{ID: "version-own", Owner: r.token(), SHA256: r.SHA256, Bytes: r.Bytes, ETag: `"etag-own"`}
|
|
return r, v
|
|
}
|
|
|
|
func TestCreateConfirmationDetectsNewerForeignVersionWithoutSideEffects(t *testing.T) {
|
|
r, own := createFixture(t)
|
|
foreign := Version{ID: "version-foreign", Owner: Digest([]byte("foreign-owner")), SHA256: Digest([]byte("foreign")), Bytes: 7, ETag: `"etag-foreign"`}
|
|
f := &fakeBackend{byID: map[string]Version{own.ID: own, foreign.ID: foreign}, latest: foreign, latestExists: true, putVersion: own}
|
|
if _, err := confirmCreate(context.Background(), f, r, own); !errors.Is(err, ErrConflict) {
|
|
t.Fatalf("concurrent newer version accepted as committed: %v", err)
|
|
}
|
|
// Confirmation runs after the journal intent exists. Deleting here would be
|
|
// an unrecorded mutation with no delete intent/receipt and would strand the
|
|
// create intent in held forever, so confirmation must be read-only.
|
|
if len(f.deletes) != 0 {
|
|
t.Fatalf("confirmation deleted without a delete intent/receipt: %v", f.deletes)
|
|
}
|
|
if _, ok := f.byID[own.ID]; !ok {
|
|
t.Fatal("own version removed without a recorded delete")
|
|
}
|
|
if _, ok := f.byID[foreign.ID]; !ok {
|
|
t.Fatal("foreign version was deleted")
|
|
}
|
|
}
|
|
|
|
func TestCreateConfirmationCommitsOnlyWhenOwnVersionIsCurrent(t *testing.T) {
|
|
r, own := createFixture(t)
|
|
f := &fakeBackend{byID: map[string]Version{own.ID: own}, latest: own, latestExists: true, putVersion: own}
|
|
got, err := confirmCreate(context.Background(), f, r, own)
|
|
if err != nil || got != own {
|
|
t.Fatalf("own current version not committed: %v %v", got, err)
|
|
}
|
|
if len(f.deletes) != 0 {
|
|
t.Fatalf("unexpected rollback %v", f.deletes)
|
|
}
|
|
}
|
|
|
|
func TestCreateConfirmationHoldsWithoutDeletingWhenCurrentVersionUnreadable(t *testing.T) {
|
|
r, own := createFixture(t)
|
|
f := &fakeBackend{byID: map[string]Version{own.ID: own}, putVersion: own, latestErr: errors.New("read failed")}
|
|
if _, err := confirmCreate(context.Background(), f, r, own); !errors.Is(err, ErrHeld) {
|
|
t.Fatalf("unreadable current version treated as terminal: %v", err)
|
|
}
|
|
if len(f.deletes) != 0 {
|
|
t.Fatalf("deleted on an unknown observation: %v", f.deletes)
|
|
}
|
|
}
|
|
|
|
func TestCreateConfirmationHoldsOnExactReadbackMismatch(t *testing.T) {
|
|
r, own := createFixture(t)
|
|
other := own
|
|
other.ETag = `"different"`
|
|
f := &fakeBackend{byID: map[string]Version{own.ID: other}, latest: other, latestExists: true, putVersion: own}
|
|
if _, err := confirmCreate(context.Background(), f, r, own); !errors.Is(err, ErrHeld) {
|
|
t.Fatalf("mismatched readback treated as committed: %v", err)
|
|
}
|
|
if len(f.deletes) != 0 {
|
|
t.Fatalf("deleted on mismatch: %v", f.deletes)
|
|
}
|
|
}
|
|
|
|
func TestCreateSendIsSingleAttemptAndNeverDeletesUnknownPut(t *testing.T) {
|
|
r, _ := createFixture(t)
|
|
f := &fakeBackend{putErr: errors.New("transport lost")}
|
|
if _, err := sendCreate(context.Background(), f, r, []byte("shared bucket object")); !errors.Is(err, ErrHeld) {
|
|
t.Fatalf("unknown PUT treated as terminal: %v", err)
|
|
}
|
|
if f.putCalls != 1 {
|
|
t.Fatalf("PUT retried: calls=%d", f.putCalls)
|
|
}
|
|
if len(f.deletes) != 0 {
|
|
t.Fatalf("deleted without a confirmed version: %v", f.deletes)
|
|
}
|
|
}
|
|
|
|
func TestPlanAuthorizesOnlyFrozenObjectList(t *testing.T) {
|
|
body := []byte("planned")
|
|
owner, digest := Digest([]byte("owner")), Digest([]byte("plan-digest"))
|
|
p := Plan{Digest: digest, Owner: owner, Objects: []ObjectBinding{{Operation: Digest([]byte("op-1")), Key: "kb/allowed/1", SHA256: Digest(body), Bytes: int64(len(body))}}}
|
|
allowed := Request{Grant: Grant{1, owner, digest}, Operation: Digest([]byte("op-1")), Key: "kb/allowed/1", Action: "create", SHA256: Digest(body), Bytes: int64(len(body))}
|
|
if !p.allows(allowed) {
|
|
t.Fatal("frozen object rejected")
|
|
}
|
|
for name, mutate := range map[string]func(*Request){
|
|
"other_kb_key": func(r *Request) { r.Key = "kb/other-kb/1" },
|
|
"other_object": func(r *Request) { r.Key = "kb/allowed/2" },
|
|
"other_operation": func(r *Request) { r.Operation = Digest([]byte("op-2")) },
|
|
} {
|
|
got := allowed
|
|
mutate(&got)
|
|
if p.allows(got) {
|
|
t.Fatalf("%s authorized outside the frozen write set", name)
|
|
}
|
|
}
|
|
dup := p
|
|
dup.Objects = append(dup.Objects, p.Objects[0])
|
|
if dup.valid() {
|
|
t.Fatal("duplicate key accepted in plan")
|
|
}
|
|
}
|