Files
seaweedfs/weed/s3api/s3api_stream_error_test.go
T
Konstantin Adzer 91eaabf371 s3: answer ClientDisconnected for a GET the client aborted before the first byte (#12707)
* s3: answer ClientDisconnected for a GET the client aborted before the first byte

Fixes #12706

* s3: tell a gone client on TLS and HTTP/2 too, and not on a connection the server closed
2026-11-17 17:15:00 -08:00

199 lines
7.2 KiB
Go

package s3api
import (
"context"
"fmt"
"net/http"
"net/http/httptest"
"testing"
"time"
"github.com/gorilla/mux"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/status"
"github.com/seaweedfs/seaweedfs/weed/filer"
"github.com/seaweedfs/seaweedfs/weed/pb/filer_pb"
"github.com/seaweedfs/seaweedfs/weed/s3api/s3err"
"github.com/seaweedfs/seaweedfs/weed/util"
"github.com/seaweedfs/seaweedfs/weed/util/chunk_cache"
util_http "github.com/seaweedfs/seaweedfs/weed/util/http"
)
func TestWriteStreamErrorResponse(t *testing.T) {
tests := []struct {
name string
err error
wantStatus int
}{
{"context canceled", context.Canceled, http.StatusInternalServerError},
{"wrapped context canceled", fmt.Errorf("resolve chunks: %w", context.Canceled), http.StatusInternalServerError},
{"grpc canceled", status.Error(codes.Canceled, "client connection is closing"), http.StatusInternalServerError},
{"deadline exceeded", context.DeadlineExceeded, http.StatusInternalServerError},
{"unwritten stream error", &StreamError{Err: context.Canceled}, http.StatusInternalServerError},
{"too many requests", util_http.ErrTooManyRequests, http.StatusServiceUnavailable},
// the recorder's default code stands for "nothing written"
{"response already written", newStreamErrorWithResponse(context.Canceled), http.StatusOK},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
rec := httptest.NewRecorder()
writeStreamErrorResponse(rec, httptest.NewRequest(http.MethodGet, "/bucket/object", nil), tt.err)
if rec.Code != tt.wantStatus {
t.Fatalf("status = %d, want %d", rec.Code, tt.wantStatus)
}
})
}
}
// TestIdleTimeoutCancelStillAnswersConnectedClient checks that a request whose
// context the idle timeout canceled can still answer its connected client, so
// a canceled stream must not return without a response.
func TestIdleTimeoutCancelStillAnswersConnectedClient(t *testing.T) {
listener, err := util.NewListener("127.0.0.1:0", 200*time.Millisecond)
if err != nil {
t.Fatal(err)
}
server := &http.Server{ConnContext: util.ConnContext, Handler: http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
// a first read stalled past the idle timeout
<-r.Context().Done()
// only the read side should be short; a write timing out would fail the
// test on a slow runner
if err := http.NewResponseController(w).SetWriteDeadline(time.Now().Add(5 * time.Second)); err != nil {
t.Error(err)
}
writeStreamErrorResponse(w, r, r.Context().Err())
})}
go server.Serve(listener)
defer server.Close()
// bounded so a broken idle cancel fails here instead of hanging the package
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
req, err := http.NewRequestWithContext(ctx, http.MethodGet, "http://"+listener.Addr().String()+"/bucket/object", nil)
if err != nil {
t.Fatal(err)
}
resp, err := http.DefaultClient.Do(req)
if err != nil {
t.Fatal(err)
}
defer resp.Body.Close()
if resp.StatusCode != http.StatusInternalServerError {
t.Fatalf("status = %d, want %d", resp.StatusCode, http.StatusInternalServerError)
}
}
// TestClientGoneBeforeFirstByteIsNotAnInternalError checks that a canceled
// stream whose client went away is answered ClientDisconnected, so an aborted
// download does not count as a server error.
func TestClientGoneBeforeFirstByteIsNotAnInternalError(t *testing.T) {
clientCancels := func(cancel context.CancelFunc, _ *httptest.Server) { cancel() }
serverCloses := func(_ context.CancelFunc, server *httptest.Server) { server.CloseClientConnections() }
clientDisconnected := s3err.GetAPIError(s3err.ErrClientDisconnected).HTTPStatusCode
tests := []struct {
name string
start func(*httptest.Server)
abort func(context.CancelFunc, *httptest.Server)
want int
}{
{"client closes the connection", (*httptest.Server).Start, clientCancels, clientDisconnected},
{"client closes the TLS connection", (*httptest.Server).StartTLS, clientCancels, clientDisconnected},
{"client resets the HTTP/2 stream", func(server *httptest.Server) {
server.EnableHTTP2 = true
server.StartTLS()
}, clientCancels, clientDisconnected},
{"server closes the connection", (*httptest.Server).Start, serverCloses, http.StatusInternalServerError},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
listener, err := util.NewListener("127.0.0.1:0", time.Minute)
if err != nil {
t.Fatal(err)
}
entered := make(chan struct{})
status := make(chan int, 1)
server := httptest.NewUnstartedServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
close(entered)
<-r.Context().Done()
rec := httptest.NewRecorder()
writeStreamErrorResponse(rec, r, r.Context().Err())
status <- rec.Code
}))
server.Listener.Close()
server.Listener = listener
server.Config.ConnContext = util.ConnContext
tt.start(server)
defer server.Close()
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
req, err := http.NewRequestWithContext(ctx, http.MethodGet, server.URL+"/bucket/object", nil)
if err != nil {
t.Fatal(err)
}
go func() {
if resp, err := server.Client().Do(req); err == nil {
resp.Body.Close()
}
}()
select {
case <-entered:
case <-time.After(5 * time.Second):
t.Fatal("the request never reached the handler")
}
tt.abort(cancel, server)
select {
case got := <-status:
if got != tt.want {
t.Fatalf("status = %d, want %d", got, tt.want)
}
case <-time.After(5 * time.Second):
t.Fatal("the request context was never canceled")
}
})
}
}
// cancelingLookupFiler cancels the request context while the first chunk
// lookup is in flight, as the idle timeout does to a client still connected.
type cancelingLookupFiler struct {
anonymousReadFiler
cancel context.CancelFunc
}
func (f *cancelingLookupFiler) LookupVolume(context.Context, *filer_pb.LookupVolumeRequest) (*filer_pb.LookupVolumeResponse, error) {
f.cancel()
return nil, status.Error(codes.Canceled, "lookup canceled")
}
func TestGetObjectAnswersRequestCanceledBeforeFirstByte(t *testing.T) {
f := &cancelingLookupFiler{anonymousReadFiler: anonymousReadFiler{entries: map[string]*filer_pb.Entry{
"/buckets/b/o": {
Name: "o",
Attributes: &filer_pb.FuseAttributes{FileSize: 11, Mtime: 1700000000},
Chunks: []*filer_pb.FileChunk{{FileId: "3,01637037d6", Size: 11, ModifiedTsNs: 1}},
},
}}}
s3a := newPutTestServer(t, startFakeFiler(t, f))
s3a.readerCache = filer.NewReaderCache(8, (*chunk_cache.TieredChunkCache)(nil), s3a.filerClient.GetLookupFileIdFunction(), s3a.filerClient)
s3a.bucketConfigCache = NewBucketConfigCache(time.Minute)
s3a.bucketConfigCache.Set("b", &BucketConfig{Name: "b"})
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
f.cancel = cancel
r := mux.SetURLVars(httptest.NewRequestWithContext(ctx, http.MethodGet, "/b/o", nil), map[string]string{"bucket": "b", "object": "o"})
w := httptest.NewRecorder()
s3a.GetObjectHandler(w, r)
if err := ctx.Err(); err != context.Canceled {
t.Fatalf("context error = %v, want %v: the lookup was never reached", err, context.Canceled)
}
if w.Code != http.StatusInternalServerError {
t.Fatalf("status = %d with %d body bytes, want %d", w.Code, w.Body.Len(), http.StatusInternalServerError)
}
}