fix(replication): preserve normalized replica metadata

Restore only the six replication-specific metadata fields after trust
validation, so streaming uploads retain their actual content encoding and
Snowball entries do not inherit ordinary metadata from the outer archive.

Include helper, authenticated PUT/COPY/multipart and Snowball regressions,
plus the R7 investigation, actual Opus 5 consensus and local verification.
The production change is based on PR #187 by Mikhail Khadarenka.

Co-authored-by: Mikhail Khadarenka <chodorenko@gmail.com>
Signed-off-by: Feng Ruohang <rh@vonng.com>
This commit is contained in:
Feng Ruohang
2026-09-16 00:00:17 +08:00
parent 9ebe81c1b3
commit 4fcdf37ce6
17 changed files with 1104 additions and 24 deletions
+33 -23
View File
@@ -246,16 +246,6 @@ func extractMetadata(ctx context.Context, mimesHeader ...textproto.MIMEHeader) (
// extractMetadata extracts metadata from map values.
func extractMetadataFromMime(ctx context.Context, v textproto.MIMEHeader, m map[string]string) error {
return extractMetadataFromMimeWithReplication(ctx, v, m, false)
}
// extractReplicationMetadataFromMime restores replication-only metadata after the
// caller has validated that the request is a trusted replication write.
func extractReplicationMetadataFromMime(ctx context.Context, v textproto.MIMEHeader, m map[string]string) error {
return extractMetadataFromMimeWithReplication(ctx, v, m, true)
}
func extractMetadataFromMimeWithReplication(ctx context.Context, v textproto.MIMEHeader, m map[string]string, allowReplication bool) error {
if v == nil {
bugLogIf(ctx, errInvalidArgument)
return errInvalidArgument
@@ -267,18 +257,14 @@ func extractMetadataFromMimeWithReplication(ctx context.Context, v textproto.MIM
nv[http.CanonicalHeaderKey(k)] = kv
}
// Save all supported headers.
// Save ordinary object metadata. Replication-only headers are restored only
// after the request has been validated as a trusted replication write.
for _, supportedHeader := range supportedHeaders {
value, ok := nv[http.CanonicalHeaderKey(supportedHeader)]
if ok {
if v, ok := replicationToInternalHeaders[supportedHeader]; ok {
if !allowReplication {
continue
}
m[v] = strings.Join(value, ",")
} else {
m[supportedHeader] = strings.Join(value, ",")
}
if _, ok := replicationToInternalHeaders[supportedHeader]; ok {
continue
}
if value, ok := nv[http.CanonicalHeaderKey(supportedHeader)]; ok {
m[supportedHeader] = strings.Join(value, ",")
}
}
@@ -287,8 +273,7 @@ func extractMetadataFromMimeWithReplication(ctx context.Context, v textproto.MIM
if !stringsHasPrefixFold(key, prefix) {
continue
}
value, ok := nv[http.CanonicalHeaderKey(key)]
if ok {
if value, ok := nv[http.CanonicalHeaderKey(key)]; ok {
m[key] = strings.Join(value, ",")
break
}
@@ -297,6 +282,31 @@ func extractMetadataFromMimeWithReplication(ctx context.Context, v textproto.MIM
return nil
}
// extractReplicationMetadataFromMime restores replication-only metadata after the
// caller has validated that the request is a trusted replication write.
func extractReplicationMetadataFromMime(ctx context.Context, v textproto.MIMEHeader, m map[string]string) error {
if v == nil {
bugLogIf(ctx, errInvalidArgument)
return errInvalidArgument
}
nv := make(textproto.MIMEHeader, len(v))
for k, kv := range v {
// Canonicalize all headers, to remove any duplicates.
nv[http.CanonicalHeaderKey(k)] = kv
}
// Ordinary object metadata belongs to the caller. Re-extracting it would
// undo normalization (such as removing aws-chunked) or copy an outer
// Snowball archive's metadata onto its individual entries.
for header, internalHeader := range replicationToInternalHeaders {
if value, ok := nv[http.CanonicalHeaderKey(header)]; ok {
m[internalHeader] = strings.Join(value, ",")
}
}
return nil
}
// Returns access credentials in the request Authorization header.
func getReqAccessCred(r *http.Request, region string) (cred auth.Credentials) {
cred, _, _ = getReqAccessKeyV4(r, region, serviceS3)
+12 -1
View File
@@ -254,6 +254,9 @@ func TestExtractMetadataFromRequestKeepsQueryCompatibility(t *testing.T) {
func TestExtractReplicationMetadataHeaders(t *testing.T) {
header := http.Header{
"Content-Type": []string{"application/wasm"},
"Content-Encoding": []string{"aws-chunked"},
"X-Amz-Meta-Source": []string{"client"},
"X-Minio-Replication-Server-Side-Encryption-Sealed-Key": []string{"sealed-key"},
"X-Minio-Replication-Server-Side-Encryption-Seal-Algorithm": []string{"DAREv2-HMAC-SHA256"},
"X-Minio-Replication-Server-Side-Encryption-Iv": []string{"iv"},
@@ -262,12 +265,17 @@ func TestExtractReplicationMetadataHeaders(t *testing.T) {
ReplicationSsecChecksumHeader: []string{"checksum"},
}
metadata := make(map[string]string)
metadata := map[string]string{
"content-type": "application/wasm",
"x-amz-meta-source": "client",
}
if err := extractReplicationMetadataFromMime(t.Context(), textproto.MIMEHeader(header), metadata); err != nil {
t.Fatalf("failed to extract replication metadata: %v", err)
}
expected := map[string]string{
"content-type": "application/wasm",
"x-amz-meta-source": "client",
"X-Minio-Internal-Server-Side-Encryption-Sealed-Key": "sealed-key",
"X-Minio-Internal-Server-Side-Encryption-Seal-Algorithm": "DAREv2-HMAC-SHA256",
"X-Minio-Internal-Server-Side-Encryption-Iv": "iv",
@@ -279,6 +287,9 @@ func TestExtractReplicationMetadataHeaders(t *testing.T) {
if !reflect.DeepEqual(metadata, expected) {
t.Fatalf("unexpected replication metadata: expected %#v, got %#v", expected, metadata)
}
if _, ok := metadata["content-encoding"]; ok {
t.Fatalf("replication metadata restored transport content-encoding: %#v", metadata)
}
}
func TestGetCopyObjectMetadataFromHeaderReplication(t *testing.T) {
+276
View File
@@ -0,0 +1,276 @@
// Copyright (c) 2026 PGSTY
// SPDX-License-Identifier: AGPL-3.0-or-later
package cmd
import (
"archive/tar"
"bytes"
"compress/gzip"
"encoding/xml"
"maps"
"net/http"
"net/http/httptest"
"net/url"
"reflect"
"strings"
"testing"
"github.com/minio/minio/internal/auth"
xhttp "github.com/minio/minio/internal/http"
)
// Exercise authenticated handlers and actual disk metadata, including the
// response headers consumers see after replication has completed.
func TestAPIReplicaContentEncoding(t *testing.T) {
defer DetectTestLeak(t)()
ExecObjectLayerAPITest(ExecObjectLayerAPITestArgs{t: t, objAPITest: testAPIReplicaContentEncoding})
}
func testAPIReplicaContentEncoding(obj ObjectLayer, instance, bucket string, router http.Handler, owner auth.Credentials, t *testing.T) {
ordinary := newObjectAttributesAuthzUser(t, instance, bucket, `"s3:PutObject","s3:GetObject"`)
replicator := newObjectAttributesAuthzUser(t, instance, bucket, `"s3:PutObject","s3:GetObject","s3:ReplicateObject"`)
for _, mode := range []string{"ordinary", "untrusted-marker", "replica"} {
for _, tc := range []struct{ name, wire, want string }{
{"bare", "aws-chunked", ""}, {"mixed", "aws-chunked,gzip", "gzip"}, {"gzip", "gzip", "gzip"},
} {
for _, operation := range []string{"put", "copy-replace", "multipart"} {
t.Run(instance+"/"+mode+"/"+tc.name+"/"+operation, func(t *testing.T) {
object := mode + "/" + tc.name + "/" + operation
payload := replicaEncodingPayload(t, tc.want)
creds := ordinary
headers := map[string]string{xhttp.ContentEncoding: tc.wire, xhttp.ContentType: "application/octet-stream", "X-Amz-Meta-Source": "encoding-test"}
if mode != "ordinary" {
headers[xhttp.MinIOSourceReplicationRequest] = "true"
}
if mode == "replica" {
creds = replicator
headers[xhttp.AmzBucketReplicationStatus] = "REPLICA"
}
send := func(method, target string, data []byte, hdrs map[string]string) *httptest.ResponseRecorder {
t.Helper()
req, err := newTestSignedRequestV4(method, target, int64(len(data)), bytes.NewReader(data), creds.AccessKey, creds.SecretKey, hdrs)
if err != nil {
t.Fatal(err)
}
return replicaEncodingServe(t, router, req, http.StatusOK)
}
switch operation {
case "put":
if strings.Contains(tc.wire, "aws-chunked") {
req := replicaEncodingStream(t, getPutObjectURL("", bucket, object), payload, creds, headers)
replicaEncodingServe(t, router, req, http.StatusOK)
} else {
send(http.MethodPut, getPutObjectURL("", bucket, object), payload, headers)
}
case "copy-replace":
source := object + "-source"
if _, err := obj.PutObject(t.Context(), bucket, source, mustGetPutObjReader(t, bytes.NewReader(payload), int64(len(payload)), "", ""), ObjectOptions{}); err != nil {
t.Fatal(err)
}
headers[xhttp.AmzCopySource] = url.QueryEscape("/" + bucket + "/" + source)
headers[xhttp.AmzMetadataDirective] = replaceDirective
send(http.MethodPut, getCopyObjectURL("", bucket, object), nil, headers)
case "multipart":
rec := send(http.MethodPost, getNewMultipartURL("", bucket, object), nil, headers)
var init InitiateMultipartUploadResponse
if err := xml.Unmarshal(rec.Body.Bytes(), &init); err != nil {
t.Fatal(err)
}
// Part/completion metadata must not replace the encoding saved at initiation.
partHeaders := map[string]string{xhttp.ContentEncoding: "br"}
if mode == "replica" {
partHeaders[xhttp.MinIOSourceReplicationRequest] = "true"
partHeaders[xhttp.AmzBucketReplicationStatus] = "REPLICA"
}
part := send(http.MethodPut, getPutObjectPartURL("", bucket, object, init.UploadID, "1"), payload, partHeaders)
partETags := part.Header()[xhttp.ETag]
if len(partETags) != 1 {
t.Fatalf("missing part ETag: %#v", part.Header())
}
complete, err := xml.Marshal(CompleteMultipartUpload{Parts: []CompletePart{{PartNumber: 1, ETag: canonicalizeETag(partETags[0])}}})
if err != nil {
t.Fatal(err)
}
send(http.MethodPost, getCompleteMultipartUploadURL("", bucket, object, init.UploadID), complete, partHeaders)
}
assertReplicaEncodingObject(t, obj, router, owner, bucket, object, tc.want, payload)
info, err := obj.GetObjectInfo(t.Context(), bucket, object, ObjectOptions{})
if err != nil {
t.Fatal(err)
}
if got := info.UserDefined[xhttp.AmzBucketReplicationStatus]; (got == "REPLICA") != (mode == "replica") {
t.Errorf("replica status %q for mode %s", got, mode)
}
if info.ContentType != "application/octet-stream" {
t.Errorf("content-type=%q", info.ContentType)
}
if value, ok := caseInsensitiveMap(info.UserDefined).Lookup("x-amz-meta-source"); !ok || value != "encoding-test" {
t.Errorf("user metadata lost: %#v", info.UserDefined)
}
})
}
}
}
t.Run(instance+"/unauthorized-replica", func(t *testing.T) {
object := "denied-replica"
req := replicaEncodingStream(t, getPutObjectURL("", bucket, object), []byte("denied"), ordinary, map[string]string{xhttp.ContentEncoding: "aws-chunked", xhttp.MinIOSourceReplicationRequest: "true", xhttp.AmzBucketReplicationStatus: "REPLICA"})
rec := replicaEncodingServe(t, router, req, http.StatusForbidden)
var response APIErrorResponse
if err := xml.Unmarshal(rec.Body.Bytes(), &response); err != nil {
t.Fatal(err)
}
if response.Code != "AccessDenied" {
t.Fatalf("expected permission denial, got %s", response.Code)
}
if _, err := obj.GetObjectInfo(t.Context(), bucket, object, ObjectOptions{}); err == nil {
t.Error("denied replica created an object")
}
})
}
func replicaEncodingPayload(t *testing.T, encoding string) []byte {
t.Helper()
data := bytes.Repeat([]byte("replica encoding payload\n"), 128)
if encoding != "gzip" {
return data
}
var b bytes.Buffer
w := gzip.NewWriter(&b)
if _, err := w.Write(data); err != nil {
t.Fatal(err)
}
if err := w.Close(); err != nil {
t.Fatal(err)
}
return b.Bytes()
}
func replicaEncodingStream(t *testing.T, target string, data []byte, creds auth.Credentials, headers map[string]string) *http.Request {
t.Helper()
const chunkSize = 64
body := bytes.NewReader(data)
req, err := newTestStreamingRequest(http.MethodPut, target, int64(len(data)), chunkSize, body)
if err != nil {
t.Fatal(err)
}
for k, v := range headers {
req.Header.Set(k, v)
}
now := UTCNow()
signature, err := signStreamingRequest(req, creds.AccessKey, creds.SecretKey, now)
if err != nil {
t.Fatal(err)
}
req, err = assembleStreamingChunks(req, body, chunkSize, creds.SecretKey, signature, now)
if err != nil {
t.Fatal(err)
}
return req
}
func replicaEncodingServe(t *testing.T, router http.Handler, req *http.Request, want int) *httptest.ResponseRecorder {
t.Helper()
rec := httptest.NewRecorder()
router.ServeHTTP(rec, req)
if rec.Code != want {
t.Fatalf("%s %s: status=%d want=%d body=%s", req.Method, req.URL, rec.Code, want, rec.Body.String())
}
return rec
}
func assertReplicaEncodingObject(t *testing.T, obj ObjectLayer, router http.Handler, creds auth.Credentials, bucket, object, encoding string, data []byte) {
t.Helper()
info, err := obj.GetObjectInfo(t.Context(), bucket, object, ObjectOptions{})
if err != nil {
t.Fatal(err)
}
if info.ContentEncoding != encoding {
t.Errorf("persisted content-encoding=%q want=%q", info.ContentEncoding, encoding)
}
if encoding == "" {
if _, present := info.UserDefined["content-encoding"]; present {
t.Error("transport-only content-encoding key persisted")
}
}
for _, method := range []string{http.MethodGet, http.MethodHead} {
req, err := newTestSignedRequestV4(method, getPutObjectURL("", bucket, object), 0, nil, creds.AccessKey, creds.SecretKey, nil)
if err != nil {
t.Fatal(err)
}
rec := replicaEncodingServe(t, router, req, http.StatusOK)
if got := rec.Header().Get(xhttp.ContentEncoding); got != encoding {
t.Errorf("%s content-encoding=%q want=%q", method, got, encoding)
}
if encoding == "" {
if _, present := rec.Header()[xhttp.ContentEncoding]; present {
t.Errorf("%s sent an empty/transport encoding header", method)
}
}
if method == http.MethodGet && !bytes.Equal(rec.Body.Bytes(), data) {
t.Errorf("GET body differs: got %d bytes want %d", rec.Body.Len(), len(data))
}
}
}
func TestAPISnowballReplicaContentEncoding(t *testing.T) {
defer DetectTestLeak(t)()
ExecObjectLayerAPITest(ExecObjectLayerAPITestArgs{t: t, objAPITest: func(obj ObjectLayer, instance, bucket string, router http.Handler, creds auth.Credentials, t *testing.T) {
for _, tc := range []struct {
name string
pax map[string]string
want string
}{
{name: "no-pax"},
{name: "pax-without-encoding", pax: map[string]string{"minio.metadata.Content-Type": "application/octet-stream"}},
{name: "pax-bare", pax: map[string]string{"minio.metadata.Content-Encoding": "aws-chunked"}},
{name: "pax-mixed", pax: map[string]string{"minio.metadata.Content-Encoding": "aws-chunked,gzip"}, want: "gzip"},
} {
t.Run(instance+"/"+tc.name, func(t *testing.T) {
object := "snowball/" + tc.name
data := replicaEncodingPayload(t, tc.want)
var archive bytes.Buffer
tw := tar.NewWriter(&archive)
if err := tw.WriteHeader(&tar.Header{Name: object, Mode: 0o600, Size: int64(len(data)), PAXRecords: tc.pax}); err != nil {
t.Fatal(err)
}
if _, err := tw.Write(data); err != nil {
t.Fatal(err)
}
if err := tw.Close(); err != nil {
t.Fatal(err)
}
var ordinaryMetadata map[string]string
// An unauthorized entry in a REPLICA request is rejected. Compare the
// same archive across ordinary and authorized replica requests instead.
for _, replica := range []bool{false, true} {
headers := map[string]string{
xhttp.ContentEncoding: "aws-chunked", xhttp.AmzSnowballExtract: "true",
xhttp.ContentType: "application/x-tar", xhttp.CacheControl: "max-age=123",
"X-Amz-Meta-Archive": "outer-request",
}
if replica {
headers[xhttp.MinIOSourceReplicationRequest] = "true"
headers[xhttp.AmzBucketReplicationStatus] = "REPLICA"
}
req := replicaEncodingStream(t, getPutObjectURL("", bucket, "archive.tar"), archive.Bytes(), creds, headers)
replicaEncodingServe(t, router, req, http.StatusOK)
assertReplicaEncodingObject(t, obj, router, creds, bucket, object, tc.want, data)
info, err := obj.GetObjectInfo(t.Context(), bucket, object, ObjectOptions{})
if err != nil {
t.Fatal(err)
}
metadata := maps.Clone(info.UserDefined)
for _, key := range []string{xhttp.AmzBucketReplicationStatus, ReservedMetadataPrefixLower + ReplicaStatus, ReservedMetadataPrefixLower + ReplicaTimestamp, "etag"} {
delete(metadata, key)
}
if !replica {
ordinaryMetadata = metadata
} else if !reflect.DeepEqual(metadata, ordinaryMetadata) {
t.Errorf("replica inherited ordinary archive metadata: got %#v want %#v", metadata, ordinaryMetadata)
}
}
})
}
}})
}
+121
View File
@@ -0,0 +1,121 @@
// Copyright (c) 2026 PGSTY
// SPDX-License-Identifier: AGPL-3.0-or-later
package cmd
import (
"maps"
"net/http"
"net/textproto"
"reflect"
"strings"
"testing"
xhttp "github.com/minio/minio/internal/http"
)
func TestExtractReplicationMetadataPreservesNormalizedMetadata(t *testing.T) {
for _, tc := range []struct {
name string
wire []string
want string
}{
{name: "absent"},
{name: "transport-only", wire: []string{"aws-chunked"}},
{name: "mixed", wire: []string{"aws-chunked,gzip"}, want: "gzip"},
{name: "gzip", wire: []string{"gzip"}, want: "gzip"},
{name: "transport-last", wire: []string{"gzip,aws-chunked"}, want: "gzip"},
{name: "multiple-values", wire: []string{"aws-chunked", "gzip"}, want: "gzip"},
// Preserve the existing exact-token grammar; whitespace is not normalized here.
{name: "space-before-gzip", wire: []string{"aws-chunked, gzip"}, want: " gzip"},
{name: "space-before-transport", wire: []string{"gzip, aws-chunked"}, want: "gzip, aws-chunked"},
} {
for _, lowercase := range []bool{false, true} {
name := tc.name + "/canonical"
if lowercase {
name = tc.name + "/lowercase"
}
t.Run(name, func(t *testing.T) {
header := http.Header{
"Content-Type": []string{"application/octet-stream"},
"X-Amz-Meta-Source": []string{"raw"},
"X-Minio-Replication-Server-Side-Encryption-Sealed-Key": []string{"sealed-key"},
"X-Minio-Replication-Server-Side-Encryption-Seal-Algorithm": []string{"DAREv2-HMAC-SHA256"},
"X-Minio-Replication-Server-Side-Encryption-Iv": []string{"iv"},
"X-Minio-Replication-Encrypted-Multipart": []string{""},
"X-Minio-Replication-Actual-Object-Size": []string{"1"},
ReplicationSsecChecksumHeader: []string{"checksum"},
xhttp.AmzMetaUnencryptedContentLength: []string{"injected-length"},
xhttp.AmzMetaUnencryptedContentMD5: []string{"injected-md5"},
}
if tc.wire != nil {
header[xhttp.ContentEncoding] = tc.wire
}
if lowercase {
h := make(http.Header, len(header))
for k, v := range header {
h[strings.ToLower(k)] = v
}
header = h
}
metadata, err := extractMetadata(t.Context(), textproto.MIMEHeader(header))
if err != nil {
t.Fatal(err)
}
if metadata["content-encoding"] != tc.want {
t.Fatalf("ordinary encoding=%q want=%q", metadata["content-encoding"], tc.want)
}
for _, internal := range replicationToInternalHeaders {
if _, ok := metadata[internal]; ok {
t.Fatalf("ordinary request accepted internal field %s", internal)
}
}
// Callers own ordinary metadata and may transform it after extraction.
metadata["content-type"] = "application/wasm"
for k := range metadata {
if strings.EqualFold(k, "x-amz-meta-source") {
metadata[k] = "caller"
}
}
want := maps.Clone(metadata)
maps.Copy(want, map[string]string{
"X-Minio-Internal-Server-Side-Encryption-Sealed-Key": "sealed-key",
"X-Minio-Internal-Server-Side-Encryption-Seal-Algorithm": "DAREv2-HMAC-SHA256",
"X-Minio-Internal-Server-Side-Encryption-Iv": "iv",
"X-Minio-Internal-Encrypted-Multipart": "",
"X-Minio-Internal-Actual-Object-Size": "1",
ReplicationSsecChecksumHeader: "checksum",
})
for range 2 {
if err := extractReplicationMetadataFromMime(t.Context(), textproto.MIMEHeader(header), metadata); err != nil {
t.Fatal(err)
}
if !reflect.DeepEqual(metadata, want) {
t.Errorf("restoration changed normalized metadata: got %#v want %#v", metadata, want)
}
}
if tc.want == "" {
if _, present := metadata["content-encoding"]; present {
t.Error("transport-only content-encoding key restored")
}
}
for _, key := range []string{xhttp.AmzMetaUnencryptedContentLength, xhttp.AmzMetaUnencryptedContentMD5} {
if _, present := caseInsensitiveMap(metadata).Lookup(key); present {
t.Errorf("redacted metadata restored: %s", key)
}
}
})
}
}
}
func TestExtractReplicationMetadataNilHeader(t *testing.T) {
metadata := map[string]string{"content-type": "application/wasm"}
want := maps.Clone(metadata)
if err := extractReplicationMetadataFromMime(t.Context(), nil, metadata); err != errInvalidArgument {
t.Fatalf("nil header: got %v want %v", err, errInvalidArgument)
}
if !reflect.DeepEqual(metadata, want) {
t.Fatalf("nil input changed metadata: %#v", metadata)
}
}
+68
View File
@@ -0,0 +1,68 @@
# R7:可信复制 Content-Encoding 修复
## 交付摘要
生产修复只改 `cmd/handler-utils.go`:可信复制只恢复六个复制专用字段,保留调用方已规范化的普通元数据。采用 [PR #187](https://github.com/pgsty/silo/pull/187) 的生产逻辑,增加准确说明 Snowball 调用方的注释。PR 原作者:Mikhail Khadarenka;本地新增回归与调查记录由本任务提供。
- `aws-chunked`:对象元数据和 GET/HEAD 不包含 Content-Encoding。
- `aws-chunked,gzip`:只保留 `gzip`,原始 gzip 字节不变。
- `gzip`:保持原值与原字节。
- 六个复制字段保留,包括空 multipart 标记和 SSE-C checksum;认证/权限门控保持原语义。
- 普通提取删除的旧 unencrypted length/MD5 用户元数据不会被复制恢复阶段重新注入。
## 方案和真实 Opus 共识
- [调查与基线复现](research.md)
- [冻结方案 v1](plan-v1.md) 与 [逐项处置附录](plan-v1.dispositions.md)
- [最终共识](consensus.md):真实 Claude Code 2.1.270,两轮显式 `claude-opus-5 --effort max`;所有实际评审 assistant 消息均为 `claude-opus-5`。第二轮 `APPROVE`,阻断 0。
- [首轮原文](review/opus-v1.md)、[第二轮原文](review/opus-v1-confirmation.md);相邻 metadata 文件记录模型、命令、源 SHA、方案/原文哈希与原始 JSONL 路径。
共识在产品代码修改前记录;Opus 审阅代码和方案,测试由本任务执行,二者分别留证。
## 兼容性与边界
Snowball 无 PAX 的可信复制条目不再继承外层归档的 content-type/cache-control/用户元数据,与普通 Snowball 一致。外层的六个复制专用字段仍可按既有规则作用于已授权条目。相同 tar 的普通和 replica 写入已纳入条目元数据一致性回归。
现有精确 token 裁剪规则保持不变:`aws-chunked, gzip` 留下带前导空格的 ` gzip``gzip, aws-chunked` 中带空格的 token 仍不会被去掉。这两条记录现状的断言不代表它们已被修复。POST 表单低层元数据提取行为也保持原样。
旧对象不会因升级自动修正;普通 COPY 保留来源已有元数据。若权威来源仍受污染,后续对账可能继续认为目标不一致并再次选择元数据复制。先核实来源版本、再协调副本的操作提案见 [存量处理设计](stored-metadata-remediation.md)。本任务未扫描或改写现网对象。
## 复验命令
在有充足空闲比例的普通测试机器上,正式测试不需要容量 overlay:
```sh
go test ./cmd -run '^Test(ExtractReplicationMetadata.*|APIReplicaContentEncoding|APISnowballReplicaContentEncoding)$' -count=1
go test -race ./cmd -run '^Test(ExtractReplicationMetadata.*|APIReplicaContentEncoding|APISnowballReplicaContentEncoding|APISnowballReplicationTrustIsPerEntry|APISSECReplicaSkipsDestinationTransforms|APISSECMultipartReplicaRoundTripWithCompression)$' -count=1
make verifiers
make build
```
本机实际命令见下述每次运行的 JSON;其中包含容量 overlay、并行度和使用的本地 golangci-lint 路径。
## 验证证据
完整命令、源文件/方案哈希、构建身份和检查结果汇总于 [verification.json](verification.json)。构建发生在本地提交前,二进制嵌入基线提交号;代码内容以验证清单中的文件哈希为准,不作为发布制品。
原始材料目录:`/Users/vonng/tmp/silo-r7-20260915-ad51/`。除原始发现阶段外,每次正式验证的 `.json` 记录命令、退出码、时间、日志哈希和四个代码文件的 SHA-256。
| 验证 | 状态与材料 |
| --- | --- |
| 原始 helper 基线 | `baseline.log`:裸/混合可信恢复失败,gzip 控制通过 |
| 原始 HTTP 基线 | `http-baseline-v2.log`:单盘及 16 盘,44 个控制通过,20 个已知缺陷失败 |
| 最终测试回退原始 helper | `exact-baseline-regression.{json,log}`:测试不变,只覆盖回基线产品文件;44 控制通过、36 预期失败(20 HTTP + 16 helper |
| 修复后的定向测试 | `fixed-targeted.{json,log}`:9 个顶层测试、80 个具名子用例全部通过 |
| 既有 SSE 与信任边界 | `fixed-sse-trust.{json,log}`SSE-C 单段/多段、SSE multipart trust、PUT/COPY 投毒、普通/复制权限、Snowball per-entry、默认桶加密、streaming trailer 等全部通过 |
| Race | `fixed-race.{json,log}`:新增 helper/HTTP/Snowball、既有 Snowball per-entry 与 SSE-C 单段/多段全部通过 |
| 仓库 verifiers | `verifiers.{json,log}`make verifiers 通过,golangci-lint 0 issues,生成文件与兼容标识检查通过;typos 未安装,按 Makefile 跳过 |
| 构建 | `build.{json,log}`make build 通过;本地 silo --version 已核对,二进制身份见 verification.json |
### 本机容量条件
未调整的 HTTP 夹具返回 507 / XMinioStorageFull,原始日志为 `http-baseline-unadapted.log`。宿主 APFS 接近满盘,触发相对空闲阈值。HTTP/既有 SSE/race 验证使用临时 Go overlay 复用仓库的 `tagTestCapacityDisk`,只改变 API 测试夹具看到的容量比率,实际对象和元数据仍读写测试磁盘。该临时文件在仓库外,不进入交付;生产容量策略没有变化。
证据为本机认证请求处理链路及实际存储、读取和既有 SSE 往返,不是双站点调度器、进程重启、网络故障或线上验收。
## 状态
研究、真实 Opus 共识、本地实现与验证均完成。结果保存在 `codex/r7-replication-content-encoding` 分支;合并、远端推送、发布、部署和现网存量处理均未执行。
+25
View File
@@ -0,0 +1,25 @@
# R7 最终方案共识
记录时间:2026-09-15T15:53:09.813317+00:00。此记录写入时产品代码仍为基线,只有调查文件和仓库外的临时测试。
## 同一版方案
- 基线:`9ebe81c1b3611f9cc73e676b5b741c2be62c467a`
- [plan-v1.md](plan-v1.md)`7af5705ebbfb0a375956d38dba059095dc16e24558290b1bd35a6ce85b9e1f96`
- [plan-v1.dispositions.md](plan-v1.dispositions.md)`d32d30f8a420f904da6ee039f0461d6281e7da44bd805d416b4970d071f0af32`
- Codex 重新计算并确认上述两个哈希未变。Opus 只读源码,明确未计算哈希、未运行测试。
## 实际讨论结果
两轮均使用 Claude Code 2.1.270,显式 `--model claude-opus-5 --effort max`。原始记录中两轮所有评审 assistant 消息均为 `claude-opus-5`;辅助模型用量与主评审模型分开记录。
1. [首轮独立评审](review/opus-v1.md)APPROVE_WITH_NONBLOCKING_NOTES,阻断 09 项非阻断意见。
2. Codex 逐项核验:采纳验证/文档建议;纠正 N1 的单包权限比较方式、收窄 N5 的重试风险表述、以源码反驳 N6 的容量适配器不存在判断。详见绑定处置附录。
3. [第二轮确认](review/opus-v1-confirmation.md)**APPROVE,阻断 0**Opus 明确接受 N1/N5 的纠正,撤回 N6 的事实判断,并同意这两个哈希所标识的 v1 组合直接进入实现。
4. Codex 同意该方案及全部最终处置。没有剩余阻断分歧;共识完成,现在开始本地实现与验证。
评审原始 JSONL、stderr、实际模型、命令、耗时及输出哈希均由 `review/*.metadata.json` 指向 `/Users/vonng/tmp/silo-r7-20260915-ad51/` 中的原始记录。首轮 Claude plan 模式尝试写自己的 plan 文件但 Write 工具被禁用,最后只以文本返回评审;未写产品文件。没有把失败、限流或别的模型当成通过。
## 授权及证据边界
共识是源代码与修复方案的认可。实现、测试、合并、发布和部署仍分别记录。本地常规修复已获工作流授权,无需再次询问;主干合并、远端发布、部署和现网存量改写不在此次范围。
@@ -0,0 +1,23 @@
# R7 v1 评审意见处置与验收补充
- 冻结方案仍为 `plan-v1.md`SHA-256 `7af5705ebbfb0a375956d38dba059095dc16e24558290b1bd35a6ce85b9e1f96`
- Opus 首轮:`APPROVE_WITH_NONBLOCKING_NOTES`,阻断 0;原始评审见 `review/opus-v1.md`
- 本文件只澄清兼容边界与验收,不改变生产补丁范围;作为 v1 的绑定附录交给 Opus 再确认。确认前仍不修改产品代码。
| 意见 | Codex 处置与证据 |
| --- | --- |
| N1Snowball 无 PAX 行为变化与 parity | 接受。可信 replica 的无 PAX 条目不再继承外层 archive 的 ordinary content-type/content-encoding/cache-control/user metadata;这一可见变化使它与普通 Snowball 一致,纳入报告。六个复制专用字段仍能由外层传给每个已授权条目,PAX 的专用字段可按现有次序覆盖。parity 测试用相同 tar 分别执行 ordinary 与 replica 请求并比较条目元数据(排除 replica 状态/时间/ETag);不能按建议字面在一个 REPLICA 请求中混入无 ReplicateObject 权限的条目并期待它成功,因为 `object-handlers.go:2788-2791` 会拒绝该条目。现有 per-entry 权限回归另行保持。 |
| N2HTTP baseline 回归护栏 | 接受,已实测。`/Users/vonng/tmp/silo-r7-20260915-ad51/http-baseline-v2.log` 包含单盘及 16 盘的真实 streaming PUT -> ObjectInfo -> GET/HEAD 失败,同期 ordinary/gzip 控制通过;还覆盖 COPY/multipart/Snowball。64 个叶子:44 控制通过,20 缺陷失败。 |
| N3:签名前注入所有头 | 接受,已落实在临时测试 `replicaEncodingStream`:先 newTestStreamingRequest、设置所有头,再 signStreamingRequest 和 assembleStreamingChunks。拒绝测试还应断言 XML 错误码为 AccessDenied,区分签名失败。 |
| N4:空格 token 现状 | 接受。helper 增加 `aws-chunked, gzip -> " gzip"``gzip, aws-chunked -> "gzip, aws-chunked"`,仅固定现有精确 token 规则,生产 normalizer 不改。后一例属于既有 token 语法限制,不能宣传为本次已修复。 |
| N5:历史污染来源反复不一致 | 接受风险并限定措辞。`bucket-replication.go:987-997` 的逐字符串比较可让仍有错误编码的来源与修正后目的对象持续不一致;在再次 heal/resync/比较时可再次选择 metadata 复制。源码证据不单独证明一个不间断热循环。存量提案应先确认并处理权威源版本,再协调各副本;记录重复元数据复制/不一致,而不是只修目的端。自动清理历史来源不进入本次生产补丁。 |
| N6:容量 adapter 不存在 | 不采纳此事实判断,但接受“临时调整不入交付”的要求。请直接读取基线 `cmd/erasure-server-pool-tags_test.go:258-265``type tagTestCapacityDisk struct{ StorageAPI }` 的 DiskInfo 返回当前 Free 作为 Total、Used=0;该文件 :131 有现有调用。此前按字符串 adapter 搜索漏掉了该类型。临时 `capacity-test-utils_test.go` 仅复用它来包装 API 夹具;原始 507 和适配日志均保留,产品容量策略不改。 |
| N7:map 迭代等价性 | 接受。现有六个 wire key 到六个 internal key 为单射,遍历顺序无关;重复不同大小写头的 canonical map 碰撞行为沿用基线,不引入新的解析规则。 |
| N8:被删除的旧加密用户字段 | 接受,根因和测试均包含 `X-Amz-Meta-X-Amz-Unencrypted-Content-Length/-Md5` 的再次注入。历史污染可能继续从来源传来;此次目标端普通提取删除后不会恢复这些字段。helper 对 canonical/lowercase 均断言不存在。 |
| N9:POST 表单路径 | 接受边界说明。POST 表单直接调用低层 extractMetadataFromMime,原本就不执行 extractMetadata 的完整归一化;本补丁保持它的现状,不顺带统一逻辑。 |
## 最终验收范围补充
正式回归保留真实分块签名、有效 gzip 字节、GET 原始字节比较;没有两站点调度器/进程重启/网络故障验收时,就只报告本地复制接收链路和既有 SSE 测试的结论。
存量修复有单独可审阅文件 `stored-metadata-remediation.md`,须按 N5 增补“权威来源优先”的顺序;没有扫描/改写现网对象的授权或动作。
+71
View File
@@ -0,0 +1,71 @@
# R7 plan v1: preserve normalized replica object metadata
## Frozen scope and source
- Date: 2026-09-15. Worktree: `/Users/vonng/.codex/worktrees/ad51/silo`.
- Local branch: `codex/r7-replication-content-encoding`.
- Baseline: `9ebe81c1b3611f9cc73e676b5b741c2be62c467a`, also returned by current `gh api repos/pgsty/silo/commits/main` and fetched `origin/main`.
- PR [#187](https://github.com/pgsty/silo/pull/187): OPEN, unmerged, no reviews/checks returned; head `b8f2fdde41dff3dc3b8db669c1d42d30ca5c1d3d`. GraphQL's PR baseRefOid is `89637554d60c27cfc51d2281d0a4fe15e415f06d`; it is not the live main checked above. Snapshot and exact diff: `/Users/vonng/tmp/silo-r7-20260915-ad51/pr187.{json,diff}`.
- Introduction: `56fa63bfd155154157cd7e1fb6dc295a3b3104ed` (2026-04-15), replication-header injection hardening. Keep its trust protections intact.
- Governing scope: PGSTY maintained stack, minimal compatible fix. No dependency, wire-format, credential, encryption algorithm or API changes.
## Root cause and observable contract
`extractMetadata` calls the ordinary extractor, removes disallowed unencrypted-length/MD5 user metadata, and trims the exact `aws-chunked` transport token from `content-encoding`. The trusted-replica restoration currently calls the same broad extractor with `allowReplication=true`. That replays all supported headers and user metadata, reversing normalization and redaction.
Expected mappings are `aws-chunked` -> absent Content-Encoding, `aws-chunked,gzip` -> `gzip`, and `gzip` -> `gzip`. Object bytes are not transformed by this fix. AWS documents this behavior in [SigV4 streaming](https://docs.aws.amazon.com/AmazonS3/latest/developerguide/sigv4-streaming.html). The helper reproduction is `/Users/vonng/tmp/silo-r7-20260915-ad51/baseline_test.go` with Go overlay and `baseline.log`; its failing expectations are evidence of the current defect, not implementation validation.
Persistence/read path: `erasure-metadata.go` reads `fi.Metadata["content-encoding"]` into ObjectInfo.ContentEncoding; `api-headers.go` exposes it on GET/HEAD. Outbound `putReplicationOpts` and metadata-only replication copy also use the object's content encoding. Preventing raw request metadata from being replayed at ingress is sufficient for this defect and avoids read-path masking.
## Input and trust boundary audit
The helper does not authenticate; callers own authentication and authorization. `evaluateReplicationTrust` requires an authenticated principal, the exact single replication marker `true`, and `s3:ReplicateObject`; restoring replica-only metadata also requires `REPLICA`. Unauthorized declared replicas are rejected; marker-only/untrusted requests retain their existing sanitized behavior. Do not move restoration earlier or make headers themselves establish trust.
| Actual caller | Metadata before restoration | Trust gate and intended result |
| --- | --- | --- |
| PutObjectHandler | extractMetadataFromReq before trust evaluation | after successful signature verification, evaluate/apply trust; only replicaTrusted restores six fields |
| CopyObjectHandler via getCpObjMetadataFromHeader | REPLACE calls extractMetadataFromReq; COPY uses source metadata | authenticated source/destination checks; allowReplicationMetadata=replicaTrusted; REPLACE preserves normalization, COPY retains existing semantics |
| NewMultipartUploadHandler | extractMetadataFromReq after trust/sanitization | replicaTrusted restores six fields into initiation metadata; parts and completion reuse saved metadata |
| PutObjectExtractHandler, outer Snowball headers | only storage class and per-entry transform metadata, not generic extractMetadata | per-entry PutObject and ReplicateObject authorization; only replicaTrusted restores six fields. No-PAX entries must not inherit ordinary outer archive metadata |
| PutObjectExtractHandler, PAX entry metadata | extractMetadata on minio.metadata.* records | reuse per-entry trust; merge normalized entry metadata plus six allowed fields. Outer ordinary archive encoding must not leak even if the PAX map omits it |
PutObjectPart, CopyObjectPart and CompleteMultipartUpload do not call this helper; no additional restoration is needed there. Validate completion persistence to catch assumptions at this boundary. POST form upload does not restore replication metadata. Metadata COPY does not normalize historical source metadata; that is deliberately outside this preventive fix.
## Proposed production patch
Adopt the production change in PR #187, adjusted only if current-context application requires it:
1. Remove the `extractMetadataFromMimeWithReplication` boolean-mode helper.
2. Ordinary `extractMetadataFromMime` keeps header canonicalization and supported/user metadata extraction, always skips the replication-only mapping keys.
3. `extractReplicationMetadataFromMime` keeps nil-input error behavior and canonical header lookup; loops only over `replicationToInternalHeaders` and joins multi-values exactly as before.
4. Never re-read ordinary supported or user metadata in the restoration helper. Preserve keys already normalized, defaulted, redacted, or set by the caller.
5. Preserve all six mappings: sealed SSE-C key, seal algorithm, IV, encrypted-multipart marker (including its empty value), actual object size, and ReplicationSsecChecksumHeader (identity mapping). Preserve canonicalized/lowercase input header compatibility.
6. Clarify the comment to cover Snowball: ordinary metadata is owned by the caller; the common normalizing path runs before restoration, while outer archive metadata is not per-entry object metadata.
No normalizer/token grammar rewrite. The current exact-token trimming semantics, malformed duplicate-cased headers, and validation of SSE field payloads are outside this bug; retain existing behavior rather than expanding accepted formats or validation rules.
## Verification matrix and acceptance
Use temporary overlay reproductions before consensus. Promote focused regressions only after recorded Opus agreement. Run targeted tests with bounded Go parallelism because sibling tasks share this host.
1. Helper pipeline: absent encoding, bare aws-chunked, aws-chunked,gzip, gzip, gzip,aws-chunked, multi-valued encoding; ordinary vs restoration; key absence for bare encoding; legitimate gzip retained; ordinary/user metadata sentinel values and redacted unencrypted metadata not restored. Exact expected six-field map, canonical/lowercase headers, empty multipart marker, nil input handling. Repeat restoration should not change ordinary metadata.
2. Real signed HTTP PUT -> persisted ObjectInfo -> GET and HEAD on the existing single-drive and 16-drive erasure fixtures. Use real streaming chunk signatures for transport cases and a valid gzip payload for gzip cases. Compare raw response bytes and content encoding; bare transport must have no header. Test authenticated ordinary, trusted replica, and marker without replication permission; declared replica without permission returns 403 and creates nothing.
3. Signed COPY REPLACE and multipart initiate/part/complete -> persisted ObjectInfo -> GET/HEAD for bare, mixed, and plain gzip. Include ordinary controls. Initiation carries object metadata; part/completion carry contrasting content encoding to prove they cannot replace it. COPY preserves existing source metadata semantics.
4. Snowball trusted entry tests with and without PAX, including PAX no Content-Encoding and PAX mixed encoding; outer aws-chunked never leaks. Existing per-entry trust test stays green.
5. Existing SSE-C single PUT and multipart replication round trips plus replication-header poisoning regressions. Helper matrix verifies all six field mappings; actual SSE-C tests verify readable ciphertext replicas, encryption metadata, checksum and multipart layout. Preserve bucket default encryption/compression behavior. Run relevant SSE-KMS/SSE-S3 option/replica tests if available without broadening R4 scope.
6. Targeted package tests, focused race run, build and repository verifiers. If environmental failures (e.g. disk free-space threshold) prevent existing tests from reaching the path, retain the original failure and use an explicitly documented temporary capacity adapter already used by the repository, keeping actual object I/O on test disks. Do not mislabel that as an unmodified pass.
7. Baseline regression must fail for raw/mixed trusted metadata and fixed code must pass identical expectations. Record exact commands, exit status, baseline/diff hashes and fixture limits. No full distributed sites/deployment acceptance claim from local handler tests.
## Stored-object remediation proposal (separate, no execution)
Upgrade only prevents new pollution. Existing source/COPY metadata can remain wrong, and rollback reopens ingress pollution without undoing repairs. Do not rewrite production objects or private xl.meta files.
A separate operator-reviewed job must inventory bucket/key/version, original Content-Encoding and complete metadata, source/replica provenance, version/ETag/size/checksum and encryption/retention settings. Identify exact aws-chunked tokens and preserve other encodings/order. Verify source bytes/encoding before deciding; gzip must not be guessed or decompressed merely from the broken label. Keep an immutable manifest and metadata backup. Test a version-preserving supported metadata operation on a local replica of the relevant setup; ordinary S3 self-COPY can create a new version/change metadata timestamps and is not a universal version-preserving repair. Resolve object-lock, SSE-C keys, concurrent changes and replication ordering before approving the concrete write plan. Apply a small approved batch with concurrency guards, re-read exact versions, verify GET/HEAD and raw bytes/checksums, then reconcile replicas. Skips/conflicts need explicit reporting and a tested rollback. This task supplies the reviewable design only.
## Effort, delivery and gate
Expected 0.5-1 engineer-day for patch, targeted tests and evidence on a familiar checkout; stored-object repair and release are separate work. Production patch is about 30 added/20 removed lines in one helper file; tests provide most of the new code.
Before implementation: actual Claude Code `--model claude-opus-5 --effort max`, read-only tools, same frozen plan hash + baseline + PR snapshot. Record raw review, actual assistant model(s), objections and dispositions. Any model mismatch/error/rate-limit is not consensus. Resolve substantive findings and get explicit approval of the same plan version before production changes. After consensus, implement and verify without another user permission request.
Deliver research, versioned plan, consensus/dispositions, minimal production diff, tests and verification summary. Local commit may package the reviewable result. No main merge, remote PR mutation, push, release, deployment, or existing-object rewrite is included.
+43
View File
@@ -0,0 +1,43 @@
# R7 调查与复现
## 结论
基线 `9ebe81c1b3611f9cc73e676b5b741c2be62c467a` 中,可信复制恢复过程把已规范化的普通元数据从原始请求中重新提取。`aws-chunked` 是传输编码,重新落盘后会被 GET/HEAD 返回。SILO 在 2026-04-15 的 `56fa63bfd155154157cd7e1fb6dc295a3b3104ed` 中引入此回归;该提交修复的复制头信任边界仍需保留。
实时核对 [PR #187](https://github.com/pgsty/silo/pull/187)OPEN、未合并,head `b8f2fdde41dff3dc3b8db669c1d42d30ca5c1d3d`;只恢复复制专用字段的方向与根因吻合。没有将 PR 自报测试当成本轮验证。
## 当前调用链
五处调用:PUT、COPY REPLACE、NewMultipartUpload、Snowball 外层请求、Snowball PAX 条目。
- PUT/COPY/multipart 使用规范化普通元数据;可信分支不应再覆盖它。
- Snowball 外层只有 storage class/条目转换信息,没有通用提取;归档外层 Content-Type/Content-Encoding 不是条目元数据。
- PAX 元数据经过普通提取;无 Content-Encoding 的 PAX 映射也不能留下先前泄漏的外层编码。
- multipart 的 Part/CopyPart/Complete 不调用该恢复函数;完成后必须检验初始化元数据确实被保留。
- 所有可信恢复均需通过认证、精确复制标记、ReplicateObject 权限和 REPLICA 状态的组合判断;Snowball 对每个条目分别鉴权。
`erasure-metadata.go` 将落盘 `content-encoding` 读入 ObjectInfo`api-headers.go` 在 GET/HEAD 返回该值。对象字节并非因此一定受损。
AWS [SigV4 streaming 规范](https://docs.aws.amazon.com/AmazonS3/latest/developerguide/sigv4-streaming.html) 要求保存对象时去掉 aws-chunked,只保留实际的内容编码;只有 aws-chunked 时读取响应不应有 Content-Encoding。
## 实测记录
原始证据根目录:`/Users/vonng/tmp/silo-r7-20260915-ad51/`
| 记录 | 结果与边界 |
| --- | --- |
| `baseline_test.go` / `baseline-overlay.json` / `baseline.log` | 原始产品代码,临时 Go 测试覆盖:ordinary bare/mixed 正常,trusted bare/mixed 重新污染,纯 gzip 正常 |
| `http-baseline-unadapted.log` | 未调整夹具的本机单盘 HTTP 上传被 507 / XMinioStorageFull 拒绝;不是 R7 结果 |
| `http-baseline.log` | 首个容量适配 HTTP 运行;PUT/COPY/Snowball 可复现;multipart 夹具错误用 Header.Get 读取了仓库直接写入的 ETag 键,完成时 InvalidPart,不能用于 multipart 结论 |
| `http_test.go` / `http-capacity-overlay.json` / `http-baseline-v2.log` | 修正 ETag 读取后:PUT、COPY REPLACE、multipart 的普通和 untrusted-marker 对照通过;trusted bare/mixed 在落盘和 GET/HEAD 中失败;trusted gzip 通过;无权 replica 返回 403 且不建对象 |
| 同一最终 HTTP 基线日志的 Snowball 部分 | no-PAX、PAX 无编码、PAX 裸编码、PAX 混合编码均复现 GET/HEAD 污染 |
最终 HTTP 基线总计 64 个叶子用例:44 个控制通过,20 个预期缺陷失败。每个用例均使用认证 HTTP handler + 实际对象磁盘。PUT 传输案例和 Snowball 使用真实流式分块签名,gzip 案例使用实际 gzip 字节;读取比较原始字节并检查 Content-Encoding。
## 容量适配的准确含义
宿主 APFS 报告约 100% 使用率,触发 SILO 的相对空闲阈值。临时 `capacity-test-utils_test.go` 使用仓库既有 `tagTestCapacityDisk` 包装 API 测试夹具,将总量/已用量报告为当前空闲量/0;实际对象写入、读取和元数据持久化仍落在测试磁盘。该 overlay 不进入产品 diff,也不调整生产容量策略。结果属于明确容量适配后的本地验证,不是未改夹具的通过。
## 方案与存量
冻结方案见 [plan-v1.md](plan-v1.md)。存量对象处理见 [stored-metadata-remediation.md](stored-metadata-remediation.md),只提供设计,本任务不执行现网对象改写。
@@ -0,0 +1,28 @@
本轮只做回应核验,未重复独立审计;无 shell,未计算哈希、未运行任何测试。
# R7 v1 第二轮确认(Opus 5
## 1. 版本与哈希
- 冻结方案:`docs/investigations/r7/plan-v1.md`,任务声明 SHA-256 **`7af5705ebbfb0a375956d38dba059095dc16e24558290b1bd35a6ce85b9e1f96`**。
- 处置附录:`docs/investigations/r7/plan-v1.dispositions.md`,任务声明 SHA-256 **`d32d30f8a420f904da6ee039f0461d6281e7da44bd805d416b4970d071f0af32`**。
- 两个哈希均按任务声明采纳,本会话无法计算,校验仍属调用方责任。产品基线 `9ebe81c1b3611f9cc73e676b5b741c2be62c467a`,工作区确认未改产品代码(`docs/investigations/r7/` 为 untracked)。生产补丁仍读 `pr187.diff`,作为提议代码而非我运行的证据。
## 2. 三个争议点的裁定
**N6:我错了,撤回。** `cmd/erasure-server-pool-tags_test.go:258-264` 确有 `type tagTestCapacityDisk struct{ StorageAPI }`,其 `DiskInfo``Total=Free, Used=0`,并已在同文件 `:131``TestReplicaWritesPreserveTagOrdering` 使用。我上轮按 “adapter” 字面 grep 漏掉了该类型,所以 plan 第 56 行 “repository already used 的临时容量适配器” 属实。撤回 N6 的事实判断,保留其被接受的部分:临时 `capacity-test-utils_test.go` 不进交付 diff,原始 507 与适配过程需记录。补充一句非阻塞:若正式回归仍需容量适配,直接复用同包内已有类型即可(不算临时旁路),产品容量策略不得改动。
**N1:接受纠正。** `object-handlers.go:2740``rawReplica` 是整包级判定,`:2788-2791` 对任何缺 `ReplicateObject` 的条目直接 `ErrAccessDenied` 并中止该条目;因此我建议的“同一 REPLICA 包内 trusted 与 untrusted 条目对比”在机制上不可能成立。Codex 的做法正确:同一 tar 分别发 ordinary 与 replica 两次请求,比较条目元数据(排除 replica 状态/时间戳/ETag)。实质结论不变且已被证据坐实——补丁前 `:2835-2838` 的恢复分支会把外层 `supportedHeaders` + 用户元数据整体灌进仅含 storage class 的 `metadata``:2802-2804`),补丁后只剩六个映射;`http-baseline-v2.log:195-201``Erasure/no-pax` 正是外层 `aws-chunked` 泄漏。可选增补(非必须):再加一条 untrusted-marker 归档对照。
**N5:接受收窄措辞。** 源码只能支撑到:`bucket-replication.go:987-997` 的逐字符串比较 → `replicationActionForTarget:1131` → 仅在 `replicateObjectToTarget:1598` 的复制任务里求值,且成功后置 `Completed`、不自我重排队。所以“每次 heal/resync/重放对账都会再次选中 `replicateMetadata`” 成立,“不间断热循环” 我上轮说过头,撤回该措辞。补救顺序“先确认并修权威源版本、再协调副本”,以及把重复元数据复制/不一致记为已知影响,均予保留。
## 3. 其余处置确认
- **N2 已用实测兑现**`http-baseline-v2.log` 是 handler 级证据,单盘 `ErasureSD` 与 16 盘 `Erasure` 均覆盖 put/copy-replace/multipart,失败精确落在 `replica/bare`persisted/GET/HEAD 均为 `aws-chunked`,期望空)与 `replica/mixed``aws-chunked,gzip` vs `gzip`),ordinary、untrusted-marker、gzip、unauthorized-replica 全通过;连同 Snowball 8 例,64 叶 = 44 通过 / 20 失败,与附录计数一致。护栏诉求已满足(该日志由本会话之外产生,我只读未跑)。
- **N3 / N7 / N8 / N9**:接受无异议。N3 额外要求断言 XML 码为 `AccessDenied` 以区分签名失败,正确。
- **N4**:接受,且两条期望值与代码一致——`handler-utils.go:357-368``,` 精确等值比较,故 `"aws-chunked, gzip" → " gzip"`(保留前导空格)、`"gzip, aws-chunked" → "gzip, aws-chunked"`。仅作现状记录,不得宣传为本次修复。
- **最终验收范围补充**:同意。无双站点调度器/重启/网络故障验收时只报告本地接收链路与既有 SSE 结论;存量修复只出设计文件,不授权扫描或改写现网对象。
## 4. 结论
**APPROVE。阻塞问题 0。** plan-v1 + 本处置附录构成的 v1 组合可直接进入实现,无需 v2;N1/N5 采用 Codex 的修正表述,N6 以我撤回告结。实现时请把 N1(无 PAX 行为变化)、N4(空格现状)、N5(收敛风险与补救顺序)落为断言或文档,并确保临时容量适配文件不出现在交付 diff 中。
@@ -0,0 +1,36 @@
{
"requested_model": "claude-opus-5",
"requested_effort": "max",
"cli_version": "2.1.270",
"baseline": "9ebe81c1b3611f9cc73e676b5b741c2be62c467a",
"plan": "plan-v1.md",
"plan_sha256": "7af5705ebbfb0a375956d38dba059095dc16e24558290b1bd35a6ce85b9e1f96",
"addendum": "plan-v1.dispositions.md",
"addendum_sha256": "d32d30f8a420f904da6ee039f0461d6281e7da44bd805d416b4970d071f0af32",
"status": "completed",
"started_at": "2026-09-15T15:51:25.514239+00:00",
"raw_output": "/Users/vonng/tmp/silo-r7-20260915-ad51/opus-v1-confirmation.jsonl",
"stderr": "/Users/vonng/tmp/silo-r7-20260915-ad51/opus-v1-confirmation.stderr.log",
"command": "claude --print --model claude-opus-5 --effort max --safe-mode --permission-mode plan --tools Read,Grep,Glob --strict-mcp-config --no-session-persistence --output-format stream-json --verbose --add-dir /Users/vonng/tmp/silo-r7-20260915-ad51",
"actual_assistant_models": [
"claude-opus-5"
],
"subtype": "success",
"is_error": false,
"duration_ms": 57910,
"num_turns": 18,
"session_id": "9b4140a8-140f-4d94-9a59-9983346709fd",
"raw_sha256": "2e2db44411a0b367607b73a2f7fe38c5125f49294f496d603c8ed4975c549bba",
"review_sha256": "a471ca03b6e68d77d01dede8c6d1a8f989bceed9f7eeb99fc36634c025eb3541",
"verdict": "APPROVE",
"blocking_findings": 0,
"completed_at": "2026-09-15T15:53:09.806502+00:00",
"auxiliary_model_ids": [
"claude-haiku-4-5-20251001",
"claude-opus-5"
],
"observed_tool_attempts": [
"Grep",
"Read"
]
}
@@ -0,0 +1,7 @@
This is round 2 of the actual R7 Opus review discussion. Product baseline remains 9ebe81c1b3611f9cc73e676b5b741c2be62c467a and NO product code has been changed. Your first actual review is /Users/vonng/.codex/worktrees/ad51/silo/docs/investigations/r7/review/opus-v1.md. It approved v1 with 9 nonblocking notes and zero blockers.
Please read the SAME frozen plan /Users/vonng/.codex/worktrees/ad51/silo/docs/investigations/r7/plan-v1.md (SHA-256 7af5705ebbfb0a375956d38dba059095dc16e24558290b1bd35a6ce85b9e1f96) and Codex's numbered replies / binding acceptance addendum /Users/vonng/.codex/worktrees/ad51/silo/docs/investigations/r7/plan-v1.dispositions.md (SHA-256 d32d30f8a420f904da6ee039f0461d6281e7da44bd805d416b4970d071f0af32). The plan+addendum is the exact v1 consensus bundle; production patch remains /Users/vonng/tmp/silo-r7-20260915-ad51/pr187.diff.
Focus this round on replies, not repeating the whole independent audit. Check the factual disagreement N6 by reading cmd/erasure-server-pool-tags_test.go lines 258-265 (tagTestCapacityDisk does exist; Grep for adapter missed it). Check N1's parity testing correction: a single REPLICA archive with an unauthorized entry rejects that entry, so equal ordinary vs replica archive uploads is the correct comparison. Check N5's narrower statement about repeated reconciliation opportunities rather than claiming an automatic continuous hot loop. N2 is now backed by /Users/vonng/tmp/silo-r7-20260915-ad51/http-baseline-v2.log. The other notes are accepted and will become assertions/docs.
Return a concise Chinese confirmation that (a) explicitly names both hashes, (b) agrees/disagrees with each disputed point N1/N5/N6 and remaining dispositions, and (c) states APPROVE or REQUEST_CHANGES and whether there are any blockers to implementing this exact v1 bundle. Do not simulate tests. No shell is available: hash checking remains the caller's responsibility. Do not attempt Write or write a Claude plan file; tools are restricted to Read/Grep/Glob and your review is the final text.
+51
View File
@@ -0,0 +1,51 @@
Write 工具在本会话被禁用,因此评审直接以回复形式交付(本次任务本就是只读评审,未改动任何文件、未运行任何测试)。
---
# R7 修复方案独立评审
## 1. 审阅版本与哈希
- **审阅对象**`/Users/vonng/.codex/worktrees/ad51/silo/docs/investigations/r7/plan-v1.md`72 行,标题 `R7 plan v1: preserve normalized replica object metadata``docs/investigations/r7/` 在 git status 中为 untracked)。
- **任务给定 SHA-256**`7af5705ebbfb0a375956d38dba059095dc16e24558290b1bd35a6ce85b9e1f96`。本会话只读且无 shell,**我未重新计算该哈希**;逐字审阅的是该路径当前内容。
- 基线 `9ebe81c1b3611f9cc73e676b5b741c2be62c467a`、引入提交 `56fa63bf…`、PR #187 的 OPEN/head 状态均按任务声明采纳,**未用 git/gh 复核**。
- `pr187.diff` 被当作“提议的代码”阅读,不视为已运行的测试;`baseline.log` 由本会话之外产生,我只读未跑。
- **性质**:源码与方案验证,非我执行的测试。
## 2. 结论
**APPROVE_WITH_NONBLOCKING_NOTES**
## 3. 阻塞问题
**无阻塞问题。** 以下为逐项核验依据。
**最小补丁充分性(充分)**:恢复辅助函数是 replica 路径上唯一能把未归一化的 ordinary 头写进对象元数据的入口。`putOptsFromHeaders`/`getDefaultOpts``cmd/object-api-options.go:388-477`)只读 SSE 与 source-* 时间戳;`completeMultipartOpts:542-548` 只取 actual-object-size 与 ssec-crc。五处调用点(`object-handlers.go:1149/2282/2836/2869``object-multipart-handlers.go:246`)全部被覆盖。
**信任边界(未改变)**`evaluateReplicationTrust``cmd/replication-trust.go:78-90`)要求已认证主体 + 精确单值 `true` 标记 + `s3:ReplicateObject``REPLICA` 声明无权限直接 403Snowball 走等价的 per-entry 内联判定(`object-handlers.go:2784-2793`)。补丁不前移恢复点、不让头部本身产生信任。
**调用链(方案描述与代码一致)**:PUT 在签名校验后评估信任、元数据在 `:2199` 已归一化;COPY REPLACE 用 `extractMetadataFromReq`、COPY 保留源语义(`:1143-1156``:1411``:1801`);多段初始化在 sanitization 之后提取(`object-multipart-handlers.go:179/233`);**分片与完成确实不需要恢复**——分片从 `mi.UserDefined` 取加密状态(`:885-886``:957-987`),完成从 `completeMultipartOpts` 取两个字段。
**六个映射与空标记**:补丁遍历 `replicationToInternalHeaders``handler-utils.go:106-114`),与基线遍历 `supportedHeaders` 的键集完全相同,且六→六为单射,故 map 迭代顺序无关;空值 multipart 标记按 key 存在性消费(`internal/crypto/metadata.go:27`),`strings.Join([]string{""}, ",")==""` 行为与基线一致。
**归一化与冗余用户元数据**:基线恢复分支会把刚被 `extractMetadata``:218-241`)删除的 `X-Amz-Meta-X-Amz-Unencrypted-Content-Length/-Md5``internal/http/headers.go:138-139`GHSA-76wf-9vgp-pj7w)按原始大小写写回,补丁一并消除。
**额外独立验证(支持方案的关键事实)**:本仓库固定的 minio-go`go.mod:71``pkg/signer/utils.go:70-87 setAwsChunkedContentEncoding`**保留调用方已设编码**并生成 `aws-chunked``aws-chunked,gzip`(无空格)。因此方案声明的 `aws-chunked→无``aws-chunked,gzip→gzip` 与真实复制线路一致,修复后目标端存储值将等于源端 `objInfo.ContentEncoding``bucket-replication.go:838`),读路径 `erasure-metadata.go:138``api-headers.go:129-131` 也成立。
## 4. 非阻塞意见
1. **Snowball 无 PAX 条目的行为变化必须显式承认并加断言**。证据:`object-handlers.go:2802-2842``metadata` 只有 storage class 与压缩键,基线恢复会把外层 tar 请求的 content-type / `x-amz-meta-*` / cache-control 复制进每个 entry;补丁后不再复制,与普通 Snowball(`:2874-2877` 分支从不做 `extractMetadata`)一致。我同意这个选择,但它超出“只去掉 aws-chunked”。最小修正:在 §Proposed patch 第 6 条写明“trusted replica 无 PAX 条目不再继承外层归档 ordinary 元数据”,并在 §Verification 4 增加断言:同一 tar 中 trusted 与 untrusted 无 PAX 条目的 UserDefined(除 replica 状态/时间戳/ETag 外)相等;同时注明“外层请求的六个字段仍套用到所有条目”是既有且有意保留的行为。
2. **回归护栏应绑定 handler 级用例**`baseline_test.go` 只覆盖 helper、绕过信任门;真正会退化的是调用点。最小修正:§Verification 7 的“基线必须失败”至少绑定一条 HTTP 用例(trusted replica streaming PUT → `GetObjectInfo().ContentEncoding`)。
3. **流式签名测试必须在签名前注入 replication 头**`newTestStreamingSignedCustomEncodingRequest``test-utils_test.go:817-834`)先 Set 编码再签名;若签名后再加 `x-amz-bucket-replication-status`,得到的是 403 SignatureDoesNotMatch,容易被误读成“未恢复元数据”。最小修正:在 §Verification 2/3 补一句,并要求区分签名失败与权限拒绝。
4. **精确 token 裁剪的空格限制未被测试固定**`handler-utils.go:357-368``,` 分割做精确等值比较,`"gzip, aws-chunked"` 不会被裁剪。同意不改语法;最小修正:§Verification 1 增加两条“记录现状”的断言用例。
5. **已污染对象的收敛性风险应进入补救段**`bucket-replication.go:987-997` 用源端 `ContentEncoding` 与目标端元数据比较,而 minio-go 在已含 `aws-chunked` token 时直接早退(`utils.go:78-80`):源端仍为 `aws-chunked` 的历史对象在目标端修复后将永久 mismatch 并反复触发 metadata 复制。最小修正:补救顺序明确为“先修源端版本、再 reconcile 副本”,并把该 churn 列为已知影响与监控项。
6. **“仓库已有的容量适配器”与现状不符**:`cmd/` 下不存在此类测试旁路(`object-api-utils.go:1302 hasSpaceFor` 无测试开关;`cmd` 内 grep `adapter` 仅命中 `object-api-interface.go:325` 注释)。最小修正:改写为“显式记录所用临时本地改动并保证其不进入交付 diff”。
7. **map 迭代等价性建议写入方案**(第 3 条补一句“顺序无关性来自单射映射”),避免未来新增映射时被误改;`nv` 对重复大小写头仍是“最后写入者胜”,与基线相同,不是本次引入。
8. **GHSA 冗余键回写的修复建议在根因段显式成句**;并注意 `putReplicationOpts``bucket-replication.go:797-813`)不像 `getCopyObjMetadata``:733-735`)那样过滤这两个键,故历史对象可能确实携带它们,修复后目标端会与普通 PUT 一样丢弃。
9. **POST 表单路径的不对称**`bucket-handlers.go:1260-1266` 直接调用 `extractMetadataFromMime`,本就不做裁剪/默认 content-type/冗余键删除;补丁未改变它,建议在方案中补半句,避免未来“顺手统一”而改变 POST 行为。
## 5. 是否同意同一 v1 方案进入实现
**同意。** 该 v1 方案的根因、信任边界、调用链与补丁范围均与当前基线源码相符,不存在阻塞缺陷;上述 9 条均为记录/测试/文档层面的处置,不需要改动补丁本体。在 Codex 逐条记录处置(尤其第 1、2、5 条)后,**同一 v1 方案可直接进入实现,无需 v2**。
最后重申两点事实边界:PR #187 diff 中的测试改动是提议代码而非已运行证据;`baseline.log` 的失败断言是既有缺陷的证据,非实现验证——两者都不是我在本会话中运行的测试。
@@ -0,0 +1,37 @@
{
"requested_model": "claude-opus-5",
"requested_effort": "max",
"cli_version": "2.1.270",
"baseline": "9ebe81c1b3611f9cc73e676b5b741c2be62c467a",
"plan": "plan-v1.md",
"plan_sha256": "7af5705ebbfb0a375956d38dba059095dc16e24558290b1bd35a6ce85b9e1f96",
"status": "completed",
"started_at": "2026-09-15T15:44:49.861232+00:00",
"raw_output": "/Users/vonng/tmp/silo-r7-20260915-ad51/opus-v1.jsonl",
"stderr": "/Users/vonng/tmp/silo-r7-20260915-ad51/opus-v1.stderr.log",
"command": "claude --print --model claude-opus-5 --effort max --safe-mode --permission-mode plan --tools Read,Grep,Glob --strict-mcp-config --no-session-persistence --output-format stream-json --verbose --add-dir /Users/vonng/tmp/silo-r7-20260915-ad51",
"actual_assistant_models": [
"claude-opus-5"
],
"observed_tool_attempts": [
"Glob",
"Grep",
"Read",
"Write"
],
"subtype": "success",
"is_error": false,
"duration_ms": 309465,
"num_turns": 62,
"session_id": "10f1e9b3-7120-4a1f-94d9-e53745849cd1",
"raw_sha256": "b749be2acbec45b978907849c741e1f71994b0ad4e13d5b5204f429c9ba408b3",
"review_sha256": "d832e461291f0ec32455ade97c9bf9cd02d31812642a4b9254dd5e06ab1cc82b",
"verdict": "APPROVE_WITH_NONBLOCKING_NOTES",
"blocking_findings": 0,
"completed_at": "2026-09-15T15:51:03.390714+00:00",
"auxiliary_model_ids": [
"claude-haiku-4-5-20251001",
"claude-opus-5"
],
"note": "Actual reviewer assistant messages all identify claude-opus-5. CLI plan mode attempted Write to a Claude plan artifact, but Write was disabled; final review was returned as text. No product changes."
}
@@ -0,0 +1,12 @@
Independently review the R7 repair plan. Do not edit files or run implementation. The user requires real Opus 5.0 discussion and explicit consensus before product code changes. Disagree when evidence warrants it; do not assume PR author claims are tests we ran.
Repository baseline: 9ebe81c1b3611f9cc73e676b5b741c2be62c467a.
Plan v1: /Users/vonng/.codex/worktrees/ad51/silo/docs/investigations/r7/plan-v1.md
Plan SHA-256: 7af5705ebbfb0a375956d38dba059095dc16e24558290b1bd35a6ce85b9e1f96
Current upstream PR snapshot and proposed production patch: /Users/vonng/tmp/silo-r7-20260915-ad51/pr187.json and /Users/vonng/tmp/silo-r7-20260915-ad51/pr187.diff
Direct current-baseline helper reproduction: /Users/vonng/tmp/silo-r7-20260915-ad51/baseline_test.go, /Users/vonng/tmp/silo-r7-20260915-ad51/baseline.log (expected assertions fail).
Read the full plan and then independently inspect relevant current code including cmd/handler-utils.go, cmd/replication-trust.go, all five restoration call sites in cmd/object-handlers.go and cmd/object-multipart-handlers.go, existing test fixtures and SSE replication consumers. The Snowball no-PAX caller has NOT already performed generic ordinary metadata extraction; explicitly evaluate the proposed behavior there.
Check: minimal patch sufficiency; ordinary and trusted/replica trust boundary; PUT/COPY/multipart/parts/completion/Snowball call chains; six SSE-only mappings and empty multipart marker/checksum; normalization and removed unsafe ordinary user metadata; correct actual HTTP tests; stored-object remedial design risks. Do not expand this into independent R4/R5 issues unless this proposed fix depends on them.
Return a review in Chinese with (1) the reviewed version and exact hash, (2) verdict APPROVE / APPROVE_WITH_NONBLOCKING_NOTES / REQUEST_CHANGES, (3) each blocking issue with severity, exact code/plan evidence and smallest correction, (4) separately numbered nonblocking notes, (5) explicit whether you agree this SAME v1 plan can proceed to implementation after Codex records its dispositions. If no blocking issues, say so. Your review is source/plan validation, not actual tests run by you.
@@ -0,0 +1,31 @@
# R7 存量错误元数据处理提案(待单独批准)
本次代码修复只阻止可信复制再次从传输头写入 `aws-chunked`。升级不会扫描或改写旧对象;普通 COPY 继续保留来源对象的既有元数据。本文件是后续操作的设计,不是已执行的迁移。
## 1. 只读清单
按桶、键和精确 version ID 记录候选;包含非当前版本,不能只检查最新版本。条件是 Content-Encoding 的逗号分隔 token 中包含 `aws-chunked`。若大小写、空格或重复值异常,单列人工核验,不能凭字符串子串匹配改写。
清单至少保存:来源及目标站点、bucket/key/version ID、完整原始 Content-Encoding、拟保留编码、ETag、对象大小、可用内容校验值、修改时间、完整普通及用户元数据、标签、Object Lock/保留期/法律保留、SSE 模式及必要密钥的可用性、复制状态。清单不保存 SSE-C 密钥或凭据。读取响应时禁用客户端自动 gzip 解码,以便核对原始字节。
仅凭错误响应头不能判断字节是什么。比对可信来源版本或独立的原始内容校验值;有 gzip 的对象确认其字节确为 gzip 并保持原字节,不重新压缩。来源也受污染、来源版本不存在或校验依据不足时,标记为需调查,不自动修复。
## 2. 制作具体变更清单
优先确认并处理权威来源的精确版本,再协调副本。若来源仍保存错误编码,复制比较器会把规范化后的目标判断为不一致;在后续 heal/resync/比较时可能反复选择元数据复制。多向复制须核对整组来源和副本,记录持续不一致及重复元数据复制。这个风险不等于已证明存在不间断重试热循环。
原则上只删除被证实属于传输层的 `aws-chunked` token:仅有该 token 时移除 Content-Encoding,有其他编码时保留顺序和值。每条候选给出前后值和可回滚的元数据快照,其余内容、元数据和对象标识的保持条件逐项列出。
普通 S3 自 COPY 可能创建新版本、更新修改时间和复制排序;它不能被当作通用的原版本元数据修复 API。先在本地同配置克隆中验证可用的受支持管理/元数据操作,再选择方案。如果必须创建替代版本,要在清单中明确 version ID、当前版本关系和调用方影响。如果没有受支持的安全路径,停止该项,不编辑 `xl.meta` 或内部盘文件。
## 3. 审批与小批执行条件
批准的是具体清单和已经验证过的写入方式。执行前再次核对 version ID、ETag、大小、原元数据和时间等并发保护;ETag 单独不足以检测元数据更新。明确写入协调或维护窗口,发生冲突则跳过。Object Lock、SSE-C、生命周期和双向复制等条件分别验证;不得为了修元数据绕过保留限制。
先在可回滚的小批次验证:精确版本 HEAD 的 Content-Encoding 正确、GET 原始字节/校验值一致、对象锁和其他元数据没有被丢弃、目标站点版本与复制状态最终一致。留下逐项结果、冲突、跳过和失败日志,再决定扩大批次。
## 4. 回滚边界
保留不可变清单和完整元数据备份;为选用的具体操作验证回滚步骤。若写入创建了新版本,回滚必须考虑 version ID 和当前版本关系,不能用“再 COPY 一次”代替证明。代码回滚会重新开放新污染入口,并不会自动还原任何已修过的元数据。
本任务未对现网执行清单扫描、对象写入、版本调整、部署或存量修复。
+230
View File
@@ -0,0 +1,230 @@
{
"recorded_at": "2026-09-15T15:59:49.705292+00:00",
"baseline": "9ebe81c1b3611f9cc73e676b5b741c2be62c467a",
"branch": "codex/r7-replication-content-encoding",
"source_sha256": {
"cmd/handler-utils.go": "76d6f98a8c9b04fcf1ae7c79d5832396bbf234bd5b5efc32a7f80dec64179b1a",
"cmd/handler-utils_test.go": "f8a53dd29170280eb007c4e43773187710f027e2aa49aadda91d2777bd0e034e",
"cmd/replication-content-encoding_test.go": "c71c4cf79a3ea6336febaf14bcb8ddfd68fcbef7625ff18830c14e9143749ee7",
"cmd/replication-metadata_test.go": "2cd3c45687d7333a9466906a278d7953fe4eeb008e07e2c7e2d167480c8b64bb"
},
"plan_sha256": {
"plan-v1.md": "7af5705ebbfb0a375956d38dba059095dc16e24558290b1bd35a6ce85b9e1f96",
"plan-v1.dispositions.md": "d32d30f8a420f904da6ee039f0461d6281e7da44bd805d416b4970d071f0af32"
},
"validation": {
"fixed-targeted": {
"baseline": "9ebe81c1b3611f9cc73e676b5b741c2be62c467a",
"files": {
"cmd/handler-utils.go": "76d6f98a8c9b04fcf1ae7c79d5832396bbf234bd5b5efc32a7f80dec64179b1a",
"cmd/handler-utils_test.go": "f8a53dd29170280eb007c4e43773187710f027e2aa49aadda91d2777bd0e034e",
"cmd/replication-content-encoding_test.go": "c71c4cf79a3ea6336febaf14bcb8ddfd68fcbef7625ff18830c14e9143749ee7",
"cmd/replication-metadata_test.go": "2cd3c45687d7333a9466906a278d7953fe4eeb008e07e2c7e2d167480c8b64bb"
},
"exact_baseline_overlay": "/Users/vonng/tmp/silo-r7-20260915-ad51/exact-baseline-overlay.json",
"recorded_at": "2026-09-15T15:55:15.454079+00:00",
"exit_code": 0,
"log": "/Users/vonng/tmp/silo-r7-20260915-ad51/fixed-targeted.log",
"log_sha256": "a30add5762881d604acffd63bca5880050b92a3ae125d208c53545ac78c9b212",
"command": [
"go",
"test",
"-p",
"2",
"-overlay",
"/Users/vonng/tmp/silo-r7-20260915-ad51/capacity-overlay.json",
"./cmd",
"-run",
"^Test(ExtractMetadataHeaders|ExtractMetadataFromRequest.*|ExtractReplicationMetadata.*|GetCopyObjectMetadataFromHeaderReplication|APIReplicaContentEncoding|APISnowballReplicaContentEncoding)$",
"-count=1",
"-v"
],
"GOMAXPROCS": "4",
"top_level_tests_passed": 9,
"leaf_subtests_passed": 80
},
"fixed-sse-trust": {
"command": [
"go",
"test",
"-p",
"2",
"-overlay",
"/Users/vonng/tmp/silo-r7-20260915-ad51/capacity-overlay.json",
"./cmd",
"-run",
"^Test(API(SSECReplicaSkipsDestinationTransforms|SSECMultipartReplicaRoundTripWithCompression|SSECMultipartReplicationTrust|PutObjectReplicationHeaderPoisoning|CopyObjectReplicationHeaderPoisoning|PutObjectReplicationTrust|SnowballReplicationTrustIsPerEntry|SnowballInheritsBucketEncryption|StreamingTrailerWithUntrustedReplicationHeaders)|CloneRequestWithoutReplicationHeaders|PutReplicationOpts.*|ReplicationTrustControlsInternalOptionsAndEvents)$",
"-count=1",
"-v"
],
"cwd": "/Users/vonng/.codex/worktrees/ad51/silo",
"started_at": "2026-09-15T15:54:14.556575+00:00",
"baseline": "9ebe81c1b3611f9cc73e676b5b741c2be62c467a",
"source_sha256": {
"cmd/handler-utils.go": "76d6f98a8c9b04fcf1ae7c79d5832396bbf234bd5b5efc32a7f80dec64179b1a",
"cmd/handler-utils_test.go": "f8a53dd29170280eb007c4e43773187710f027e2aa49aadda91d2777bd0e034e",
"cmd/replication-content-encoding_test.go": "c71c4cf79a3ea6336febaf14bcb8ddfd68fcbef7625ff18830c14e9143749ee7",
"cmd/replication-metadata_test.go": "2cd3c45687d7333a9466906a278d7953fe4eeb008e07e2c7e2d167480c8b64bb"
},
"GOMAXPROCS": "4",
"GOFLAGS": null,
"status": "completed",
"log": "/Users/vonng/tmp/silo-r7-20260915-ad51/fixed-sse-trust.log",
"exit_code": 0,
"duration_seconds": 11.364,
"completed_at": "2026-09-15T15:54:25.939958+00:00",
"log_sha256": "09222aaea6f0504dce7a801d5f392df77728ebd9875f4fef9dcdb28f71ce7b5a"
},
"fixed-race": {
"command": [
"go",
"test",
"-race",
"-p",
"2",
"-overlay",
"/Users/vonng/tmp/silo-r7-20260915-ad51/capacity-overlay.json",
"./cmd",
"-run",
"^Test(ExtractReplicationMetadata.*|APIReplicaContentEncoding|APISnowballReplicaContentEncoding|APISnowballReplicationTrustIsPerEntry|APISSECReplicaSkipsDestinationTransforms|APISSECMultipartReplicaRoundTripWithCompression)$",
"-count=1",
"-v"
],
"cwd": "/Users/vonng/.codex/worktrees/ad51/silo",
"started_at": "2026-09-15T15:55:27.787466+00:00",
"baseline": "9ebe81c1b3611f9cc73e676b5b741c2be62c467a",
"source_sha256": {
"cmd/handler-utils.go": "76d6f98a8c9b04fcf1ae7c79d5832396bbf234bd5b5efc32a7f80dec64179b1a",
"cmd/handler-utils_test.go": "f8a53dd29170280eb007c4e43773187710f027e2aa49aadda91d2777bd0e034e",
"cmd/replication-content-encoding_test.go": "c71c4cf79a3ea6336febaf14bcb8ddfd68fcbef7625ff18830c14e9143749ee7",
"cmd/replication-metadata_test.go": "2cd3c45687d7333a9466906a278d7953fe4eeb008e07e2c7e2d167480c8b64bb"
},
"GOMAXPROCS": "4",
"GOFLAGS": null,
"status": "completed",
"log": "/Users/vonng/tmp/silo-r7-20260915-ad51/fixed-race.log",
"exit_code": 0,
"duration_seconds": 48.566,
"completed_at": "2026-09-15T15:56:16.372187+00:00",
"log_sha256": "b68af50412a8c1c03ea91aa40e72314ba9026798ac5dafb0d1580bc9824526b2"
},
"verifiers": {
"command": [
"make",
"verifiers",
"GOLANGCI=/Users/vonng/pgsty/silo/.bin/golangci/v2.13.1/golangci-lint"
],
"cwd": "/Users/vonng/.codex/worktrees/ad51/silo",
"started_at": "2026-09-15T15:56:40.045654+00:00",
"baseline": "9ebe81c1b3611f9cc73e676b5b741c2be62c467a",
"source_sha256": {
"cmd/handler-utils.go": "76d6f98a8c9b04fcf1ae7c79d5832396bbf234bd5b5efc32a7f80dec64179b1a",
"cmd/handler-utils_test.go": "f8a53dd29170280eb007c4e43773187710f027e2aa49aadda91d2777bd0e034e",
"cmd/replication-content-encoding_test.go": "c71c4cf79a3ea6336febaf14bcb8ddfd68fcbef7625ff18830c14e9143749ee7",
"cmd/replication-metadata_test.go": "2cd3c45687d7333a9466906a278d7953fe4eeb008e07e2c7e2d167480c8b64bb"
},
"GOMAXPROCS": "4",
"GOFLAGS": "-p=2",
"status": "completed",
"log": "/Users/vonng/tmp/silo-r7-20260915-ad51/verifiers.log",
"exit_code": 0,
"duration_seconds": 102.527,
"completed_at": "2026-09-15T15:58:22.585543+00:00",
"log_sha256": "e42a5bb55f5c1ebfcf02cebebf6d82cf1ec5a2d74590cdf838deba16dd80bfdf"
},
"build": {
"command": [
"make",
"build"
],
"cwd": "/Users/vonng/.codex/worktrees/ad51/silo",
"started_at": "2026-09-15T15:58:33.660305+00:00",
"baseline": "9ebe81c1b3611f9cc73e676b5b741c2be62c467a",
"source_sha256": {
"cmd/handler-utils.go": "76d6f98a8c9b04fcf1ae7c79d5832396bbf234bd5b5efc32a7f80dec64179b1a",
"cmd/handler-utils_test.go": "f8a53dd29170280eb007c4e43773187710f027e2aa49aadda91d2777bd0e034e",
"cmd/replication-content-encoding_test.go": "c71c4cf79a3ea6336febaf14bcb8ddfd68fcbef7625ff18830c14e9143749ee7",
"cmd/replication-metadata_test.go": "2cd3c45687d7333a9466906a278d7953fe4eeb008e07e2c7e2d167480c8b64bb"
},
"GOMAXPROCS": "4",
"GOFLAGS": "-p=2",
"status": "completed",
"log": "/Users/vonng/tmp/silo-r7-20260915-ad51/build.log",
"exit_code": 0,
"duration_seconds": 24.007,
"completed_at": "2026-09-15T15:58:57.722704+00:00",
"log_sha256": "6ba9b545236be964861749c72e7609edf12b8f470df30d1ede8fd62f497e629b"
}
},
"counterfactual": {
"command": [
"go",
"test",
"-p",
"2",
"-overlay",
"/Users/vonng/tmp/silo-r7-20260915-ad51/exact-baseline-overlay.json",
"./cmd",
"-run",
"^Test(ExtractReplicationMetadataPreservesNormalizedMetadata|APIReplicaContentEncoding|APISnowballReplicaContentEncoding)$",
"-count=1",
"-v"
],
"cwd": "/Users/vonng/.codex/worktrees/ad51/silo",
"started_at": "2026-09-15T15:54:49.754711+00:00",
"baseline": "9ebe81c1b3611f9cc73e676b5b741c2be62c467a",
"source_sha256": {
"cmd/handler-utils.go": "76d6f98a8c9b04fcf1ae7c79d5832396bbf234bd5b5efc32a7f80dec64179b1a",
"cmd/handler-utils_test.go": "f8a53dd29170280eb007c4e43773187710f027e2aa49aadda91d2777bd0e034e",
"cmd/replication-content-encoding_test.go": "c71c4cf79a3ea6336febaf14bcb8ddfd68fcbef7625ff18830c14e9143749ee7",
"cmd/replication-metadata_test.go": "2cd3c45687d7333a9466906a278d7953fe4eeb008e07e2c7e2d167480c8b64bb"
},
"GOMAXPROCS": "4",
"GOFLAGS": null,
"status": "completed",
"log": "/Users/vonng/tmp/silo-r7-20260915-ad51/exact-baseline-regression.log",
"exit_code": 1,
"duration_seconds": 27.026,
"completed_at": "2026-09-15T15:55:16.823655+00:00",
"log_sha256": "75d42b2a711c6d9a9f6d277449d1428e768e04ab10a2a331103b554d75ab17f8",
"expected_negative": true,
"reason": "Only production handler-utils.go reverted to baseline through an overlay; final regression tests and capacity fixture unchanged",
"passed_leaf_count": 44,
"failed_leaf_count": 36,
"effective_production_override_sha256": {
"cmd/handler-utils.go": "e647b53e5288d57ddbaacc5549d76ced0123b5e0cb630450cf071ffc78818398"
}
},
"binary": {
"path": "/Users/vonng/.codex/worktrees/ad51/silo/silo",
"sha256": "c346ee4edf575bf6232689d25a7e38caa44ddd69dfa919df96c05aba4bb04c77",
"size": 93054290,
"version_output": "silo version DEVELOPMENT.2026-09-15T15-14-22Z (commit-id=9ebe81c1b3611f9cc73e676b5b741c2be62c467a)\nRuntime: go1.27.1 darwin/arm64\nLicense: GNU AGPLv3 - https://www.gnu.org/licenses/agpl-3.0.html\nCopyright: 2015-2025 MinIO, Inc.\nModifications: Copyright 2025-2026 PGSTY\nSource compatibility: based on MinIO technology\n",
"note": "Built and validated from the recorded uncommitted candidate file hashes; embedded commit ID is the baseline. This is not a release artifact."
},
"capacity_overlay": {
"path": "/Users/vonng/tmp/silo-r7-20260915-ad51/capacity-overlay.json",
"sha256": "aa20dd65d323f09542d2317fc1c7e24fff67cf45e831057ed0e2b0be0a4628dd",
"fixture_path": "/Users/vonng/tmp/silo-r7-20260915-ad51/capacity-test-utils_test.go",
"fixture_sha256": "d6bf8cc58b651c86ca02063fecab14c59c950b345acf739d979e553c6c2a0897",
"tracked": false
},
"remote_pr_state": {
"headRefOid": "b8f2fdde41dff3dc3b8db669c1d42d30ca5c1d3d",
"mergedAt": null,
"reviews": [],
"state": "OPEN",
"statusCheckRollup": [],
"updatedAt": "2026-09-15T07:07:26Z"
},
"remote_main": {
"message": "Merge pull request #192 from pgsty/codex/iam-revision-tombstones\n\nfix(iam): retain revocation versions through replay and recovery",
"sha": "9ebe81c1b3611f9cc73e676b5b741c2be62c467a"
},
"limits": [
"HTTP/SSE/race tests use a temporary capacity overlay, with real disk I/O.",
"typos was not installed and Makefile skipped it.",
"No full distributed two-site scheduler/restart/network-fault acceptance.",
"No merge, remote push, release, deployment or live stored-object rewrite."
]
}