fix(server): answer file-serving errors as JSON, not the media type (#6516)

This commit is contained in:
Santhi Prakash
2026-11-01 09:46:55 +05:30
committed by GitHub
parent b9a48a70eb
commit 422afea881
4 changed files with 109 additions and 2 deletions
+9
View File
@@ -41,6 +41,15 @@ func WriteError(w http.ResponseWriter, r *http.Request, err error) {
if errors.As(err, &publicError) {
code, message = publicError.Code, publicError.Message
}
// Handlers may have prepared representation headers for the body they
// meant to serve before failing (e.g. the file server sets the attachment's
// Content-Type and Content-Disposition up front). The error body is JSON,
// so the stale values must not leak onto the response: a media-typed error
// gets handed to the browser's document viewer instead of being read.
h := w.Header()
h.Del("Content-Type")
h.Del("Content-Disposition")
h.Del("Content-Length")
if r.Method == http.MethodHead {
w.WriteHeader(code)
return
+8 -2
View File
@@ -116,14 +116,20 @@ func TestJSONFailureBeforeCommit(t *testing.T) {
require.JSONEq(t, `{"message":"Internal Server Error"}`, rec.Body.String())
}
func TestErrorPreservesExistingContentType(t *testing.T) {
// The error body is always JSON, so representation headers a handler prepared
// for the response it meant to serve must not survive onto the error: a
// media-typed error gets handed to the browser's document viewer (Chrome's
// "Failed to load PDF document" on usememos/memos#6515) instead of read.
func TestErrorUsesJSONContentType(t *testing.T) {
rec := httptest.NewRecorder()
Func(func(w http.ResponseWriter, _ *http.Request) error {
w.Header().Set("Content-Type", "video/mp4")
w.Header().Set("Content-Disposition", "attachment")
return &Error{Code: http.StatusRequestedRangeNotSatisfiable, Message: "requested range not satisfiable"}
}).ServeHTTP(rec, httptest.NewRequest(http.MethodGet, "/", nil))
require.Equal(t, http.StatusRequestedRangeNotSatisfiable, rec.Code)
require.Equal(t, "video/mp4", rec.Header().Get("Content-Type"))
require.Equal(t, "application/json", rec.Header().Get("Content-Type"))
require.Empty(t, rec.Header().Get("Content-Disposition"))
require.JSONEq(t, `{"message":"requested range not satisfiable"}`, rec.Body.String())
}
+8
View File
@@ -67,3 +67,11 @@ func (s *Server) GetObject(bucket, key string) ([]byte, error) {
defer object.Contents.Close()
return io.ReadAll(object.Contents)
}
// DeleteObject removes an object directly from the in-memory store, bypassing
// the HTTP API, for arranging state where the backend no longer holds an
// attachment's bytes.
func (s *Server) DeleteObject(bucket, key string) error {
_, err := s.memory.DeleteObject(bucket, key)
return err
}
+84
View File
@@ -101,6 +101,90 @@ func TestServeAttachmentFile_S3(t *testing.T) {
require.Empty(t, multiRangeRecorder.Header().Get("Content-Range"))
}
// A failed media fetch must answer with the JSON error it actually is, not the
// attachment's media type: browsers route a Content-Type like application/pdf
// to their document viewer, which then reports a misleading "Failed to load
// PDF document" for the JSON body (usememos/memos#6515).
func TestServeAttachmentFile_StorageFailureIsAJSONError(t *testing.T) {
ctx := context.Background()
fake := fakes3.New(t, "file-server-attachments")
svc, fs, stores, cleanup := newShareAttachmentTestServices(ctx, t)
defer cleanup()
configuredStorage := &storepb.Storage{
Id: "s3-files",
Name: "File server S3",
Type: storepb.StorageType_STORAGE_TYPE_S3,
Config: &storepb.Storage_S3Config{S3Config: fake.Config("file-server-attachments")},
}
_, err := stores.UpsertInstanceSetting(ctx, &storepb.InstanceSetting{
Key: storepb.InstanceSettingKey_STORAGE,
Value: &storepb.InstanceSetting_StorageSetting{StorageSetting: &storepb.InstanceStorageSetting{
FilepathTemplate: "files/{uuid}_{filename}",
Storages: []*storepb.Storage{configuredStorage},
DefaultStorageId: configuredStorage.Id,
}},
})
require.NoError(t, err)
creator, err := stores.CreateUser(ctx, &store.User{
Username: "s3-failure-owner",
Role: store.RoleUser,
Email: "s3-failure-owner@example.com",
})
require.NoError(t, err)
creatorCtx := context.WithValue(ctx, auth.UserIDContextKey, creator.ID)
var attachments []*apipb.Attachment
for _, spec := range []struct{ filename, contentType string }{
{"document.pdf", "application/pdf"},
{"archive.zip", "application/zip"},
} {
attachment, err := svc.CreateAttachment(creatorCtx, &apipb.CreateAttachmentRequest{Attachment: &apipb.Attachment{
Filename: spec.filename,
Type: spec.contentType,
Content: []byte("s3 bytes"),
}})
require.NoError(t, err)
attachments = append(attachments, attachment)
}
_, err = svc.CreateMemo(creatorCtx, &apipb.CreateMemoRequest{Memo: &apipb.Memo{
Content: "public S3 attachments",
Visibility: apipb.Visibility_PUBLIC,
Attachments: []*apipb.Attachment{{Name: attachments[0].Name}, {Name: attachments[1].Name}},
}})
require.NoError(t, err)
e := http.NewServeMux()
fs.RegisterRoutes(e, http.HandlerFunc(httphandler.NotFound))
// Healthy PDFs keep their media type and are served inline so a new tab
// renders them in the browser's document viewer.
recorder := httptest.NewRecorder()
e.ServeHTTP(recorder, httptest.NewRequest(http.MethodGet, fmt.Sprintf("/file/%s/%s", attachments[0].Name, attachments[0].Filename), nil))
require.Equal(t, http.StatusOK, recorder.Code)
require.Equal(t, "application/pdf", recorder.Header().Get("Content-Type"))
require.Empty(t, recorder.Header().Get("Content-Disposition"))
// Drop the backing objects so the S3 reads fail after the handler has
// already prepared the attachments' media headers.
for _, attachment := range attachments {
uid := strings.TrimPrefix(attachment.Name, "attachments/")
stored, err := svc.Store.GetAttachment(ctx, &store.FindAttachment{UID: &uid})
require.NoError(t, err)
require.NoError(t, fake.DeleteObject("file-server-attachments", stored.Payload.GetS3Object().Key))
}
for _, attachment := range attachments {
recorder := httptest.NewRecorder()
e.ServeHTTP(recorder, httptest.NewRequest(http.MethodGet, fmt.Sprintf("/file/%s/%s", attachment.Name, attachment.Filename), nil))
require.Equal(t, http.StatusInternalServerError, recorder.Code)
require.Equal(t, "application/json", recorder.Header().Get("Content-Type"))
require.Empty(t, recorder.Header().Get("Content-Disposition"))
require.Contains(t, recorder.Body.String(), "failed to stream from S3")
}
}
func TestServeAttachmentFile_ShareTokenAllowsDirectMemoAttachment(t *testing.T) {
ctx := context.Background()
svc, fs, stores, cleanup := newShareAttachmentTestServices(ctx, t)