Files
boojack 3feb08737b fix(server): log file-serving failures and answer missing local files as JSON
WriteError now logs the cause of a server error, which the public JSON
body never carries, unless the client has already gone away. The header
reset and envelope move into a shared writer the panic recoverer uses
too, so one failure logs once. The doc comment states the header contract.

A local attachment whose file is gone from disk answers a JSON 404 like
every other storage failure instead of net/http's plain-text page.

The export handler no longer strips the archive headers itself and logs
only the committed case the wrapper cannot see. The fake S3 and local
storage test setups are shared helpers, and the 416 test pins that
Content-Range survives the header reset.
2026-11-01 12:30:49 +08:00

139 lines
5.2 KiB
Go

package fileserver
import (
"context"
"io"
"log/slog"
"math"
"mime"
"net/http"
"strconv"
"time"
"github.com/usememos/memos/core/access"
"github.com/usememos/memos/core/memoexport"
"github.com/usememos/memos/internal/httphandler"
"github.com/usememos/memos/internal/ratelimit"
"github.com/usememos/memos/store"
)
// memoExportRoute downloads one user's Memos export file. The identifier is
// the username, as for avatars.
const memoExportRoute = "/file/users/{identifier}/export"
// MemoExporter writes one user's Memos export file. The API service
// implements it; the file server owns the HTTP side of an export so the
// archive streams to the client instead of being held in memory.
type MemoExporter interface {
WriteMemoExport(ctx context.Context, user *store.User, w io.Writer, exportTime time.Time) error
}
// serveMemoExport streams a user's Memos export file to an instance
// administrator. Only one export runs at a time; a second request is refused
// with 429. HEAD runs every check and answers with the headers alone, so a
// client can learn about a refusal before the browser starts a download.
func (s *FileServerService) serveMemoExport(w http.ResponseWriter, r *http.Request) error {
ctx := r.Context()
if s.MemoExporter == nil {
return &httphandler.Error{Code: http.StatusNotFound, Message: http.StatusText(http.StatusNotFound)}
}
setSecurityHeaders(w)
w.Header().Set("Cache-Control", privateAttachmentCacheControl)
caller, err := s.getCurrentUser(ctx, r)
if err != nil {
return &httphandler.Error{Code: http.StatusInternalServerError, Message: "failed to get current user", Cause: err}
}
if caller == nil {
return &httphandler.Error{Code: http.StatusUnauthorized, Message: "unauthorized access"}
}
if !access.IsInstanceAdmin(caller) {
return &httphandler.Error{Code: http.StatusForbidden, Message: "forbidden access"}
}
identifier := r.PathValue("identifier")
user, err := s.Store.GetUser(ctx, &store.FindUser{Username: &identifier})
if err != nil {
return &httphandler.Error{Code: http.StatusInternalServerError, Message: "failed to get user", Cause: err}
}
if user == nil {
return &httphandler.Error{Code: http.StatusNotFound, Message: "user not found"}
}
preflight := r.Method == http.MethodHead
if err := s.admitMemoExport(w, caller, preflight); err != nil {
return err
}
if !preflight {
defer s.memoExportSemaphore.Release(1)
}
exportTime := time.Now().UTC().Truncate(time.Second)
w.Header().Set("Content-Type", memoexport.MediaType)
w.Header().Set("Content-Disposition", mime.FormatMediaType("attachment", map[string]string{"filename": memoExportFilename(user.Username, exportTime)}))
if preflight {
w.WriteHeader(http.StatusOK)
return nil
}
body := &commitOnWrite{ResponseWriter: w}
if err := s.MemoExporter.WriteMemoExport(ctx, user, body, exportTime); err != nil {
// Before the first byte this becomes a JSON 500, which the handler
// wrapper logs and strips the archive headers from. After it, the
// response is already committed and the client receives a truncated
// archive, which the wrapper leaves alone, so that case is logged here.
if body.committed && ctx.Err() == nil {
slog.Error("memo export failed", slog.Int("user", int(user.ID)), slog.Int("caller", int(caller.ID)), slog.Any("error", err))
}
return &httphandler.Error{Code: http.StatusInternalServerError, Message: "failed to export memos", Cause: err}
}
return nil
}
// admitMemoExport charges the caller's archive budget and takes the export
// lock. A preflight only looks: it consumes no budget and releases the lock at
// once, so it reports what a GET would meet without doing its work.
func (s *FileServerService) admitMemoExport(w http.ResponseWriter, caller *store.User, preflight bool) error {
key := strconv.Itoa(int(caller.ID))
if s.RateLimiter != nil {
var decision ratelimit.Decision
if preflight {
decision = s.RateLimiter.Allowed(ratelimit.ScopeArchiveUser, key, 1)
} else {
decision = s.RateLimiter.Consume(ratelimit.ScopeArchiveUser, key, 1)
}
if !decision.Allowed {
w.Header().Set("Retry-After", strconv.Itoa(max(int(math.Ceil(decision.RetryAfter.Seconds())), 1)))
return &httphandler.Error{Code: http.StatusTooManyRequests, Message: "too many exports, try again later"}
}
}
if !s.memoExportSemaphore.TryAcquire(1) {
if s.RateLimiter != nil && !preflight {
s.RateLimiter.Refund(ratelimit.ScopeArchiveUser, key, 1)
}
return &httphandler.Error{Code: http.StatusTooManyRequests, Message: "another export is running, try again later"}
}
if preflight {
s.memoExportSemaphore.Release(1)
}
return nil
}
// memoExportFilename is memos-export-<username>-<YYYYMMDDTHHMMSSZ>.zip, the
// name the export format document specifies.
func memoExportFilename(username string, exportTime time.Time) string {
return "memos-export-" + memoexport.SafeFilename(username) + "-" + exportTime.UTC().Format("20060102T150405Z") + ".zip"
}
// commitOnWrite records whether any byte reached the client, so a failure
// can be reported as an error response only while that is still possible.
type commitOnWrite struct {
http.ResponseWriter
committed bool
}
func (c *commitOnWrite) Write(p []byte) (int, error) {
c.committed = true
return c.ResponseWriter.Write(p)
}