Skip to content

SeaweedFS is a distributed storage system for object storage (S3), file systems, Iceberg table buckets, and Lance vector buckets, designed to handle billions of files with O(1) disk access and effortless horizontal scaling.

17.1 KB
Raw Blame
package weed_server

import (
	"bufio"
	"bytes"
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"io"
	"io/fs"
	"mime"
	"mime/multipart"
	"net/http"
	"net/url"
	"path"
	"path/filepath"
	"strconv"
	"strings"
	"sync"
	"time"

	"github.com/seaweedfs/seaweedfs/weed/s3api/s3_constants"
	"github.com/seaweedfs/seaweedfs/weed/util/request_id"
	"google.golang.org/grpc/metadata"

	"github.com/seaweedfs/seaweedfs/weed/filer"

	"google.golang.org/grpc"

	"github.com/gorilla/mux"
	"github.com/seaweedfs/seaweedfs/weed/glog"
	"github.com/seaweedfs/seaweedfs/weed/operation"
	"github.com/seaweedfs/seaweedfs/weed/pb/filer_pb"
	"github.com/seaweedfs/seaweedfs/weed/stats"
	"github.com/seaweedfs/seaweedfs/weed/storage/needle"
)

var serverStats *stats.ServerStats
var startTime = time.Now()
var writePool = sync.Pool{New: func() interface{} {
	return bufio.NewWriterSize(nil, 128*1024)
},
}

// ErrCacheNotReady signals that a remote-only object's local cache is still
// filling. Callers should map it to 503 + Retry-After so SDKs back off and retry.
var ErrCacheNotReady = errors.New("remote object not cached yet")

// writePrepareWriteFnErr writes an HTTP response for an error from
// prepareWriteFn, before any 2xx headers have been written. Client cancels are
// silent; filer_pb.ErrNotFound becomes 404; ErrCacheNotReady becomes 503 +
// Retry-After; everything else is 500. Strips headers that described the
// success body (Content-Length / Content-Range / Content-Disposition / ETag /
// Last-Modified) so they don't get attached to the error response.
func writePrepareWriteFnErr(w http.ResponseWriter, err error) {
	for _, h := range []string{"Content-Length", "Content-Range", "Content-Disposition", "ETag", "Last-Modified"} {
		w.Header().Del(h)
	}
	switch {
	case errors.Is(err, context.Canceled):
		glog.V(3).Infof("ProcessRangeRequest: client disconnected: %v", err)
	case errors.Is(err, filer_pb.ErrNotFound):
		http.Error(w, err.Error(), http.StatusNotFound)
	case errors.Is(err, ErrCacheNotReady):
		glog.V(1).Infof("ProcessRangeRequest: cache not ready, returning 503: %v", err)
		w.Header().Set("Retry-After", "5")
		http.Error(w, err.Error(), http.StatusServiceUnavailable)
	default:
		glog.Errorf("ProcessRangeRequest: %v", err)
		http.Error(w, err.Error(), http.StatusInternalServerError)
	}
}

func init() {
	serverStats = stats.NewServerStats()
	go serverStats.Start()
}

// bodyAllowedForStatus is a copy of http.bodyAllowedForStatus non-exported function.
func bodyAllowedForStatus(status int) bool {
	switch {
	case status >= 100 && status <= 199:
		return false
	case status == http.StatusNoContent:
		return false
	case status == http.StatusNotModified:
		return false
	}
	return true
}

func writeJson(w http.ResponseWriter, r *http.Request, httpStatus int, obj interface{}) (err error) {
	if !bodyAllowedForStatus(httpStatus) {
		return
	}

	var bytes []byte
	if obj != nil {
		if r.URL.Query().Get("pretty") != "" {
			bytes, err = json.MarshalIndent(obj, "", "  ")
		} else {
			bytes, err = json.Marshal(obj)
		}
	}
	if err != nil {
		return
	}

	if httpStatus >= 400 {
		glog.V(0).Infof("response method:%s URL:%s with httpStatus:%d and JSON:%s",
			r.Method, redactedURL(r), httpStatus, string(bytes))
	}

	w.Header().Set("Content-Type", "application/json")
	w.Header().Set("X-Content-Type-Options", "nosniff")
	w.WriteHeader(httpStatus)
	_, err = w.Write(bytes)
	return
}

func redactedURL(r *http.Request) string {
	if _, ok := r.URL.Query()["jwt"]; !ok {
		return r.URL.String()
	}
	u := *r.URL
	q := u.Query()
	q.Set("jwt", "[redacted]")
	u.RawQuery = q.Encode()
	return u.String()
}

// wrapper for writeJson - just logs errors
func writeJsonQuiet(w http.ResponseWriter, r *http.Request, httpStatus int, obj interface{}) {
	if err := writeJson(w, r, httpStatus, obj); err != nil {
		glog.V(0).Infof("error writing JSON status %s %d: %v", redactedURL(r), httpStatus, err)
		glog.V(1).Infof("JSON content: %+v", obj)
	}
}
func writeJsonError(w http.ResponseWriter, r *http.Request, httpStatus int, err error) {
	m := make(map[string]interface{})
	m["error"] = err.Error()
	glog.V(1).Infof("error JSON response status %d: %s", httpStatus, m["error"])
	writeJsonQuiet(w, r, httpStatus, m)
}

func debug(params ...interface{}) {
	glog.V(4).Infoln(params...)
}

func submitForClientHandler(w http.ResponseWriter, r *http.Request, masterFn operation.GetMasterFn, grpcDialOption grpc.DialOption, fileSizeLimitBytes int64) {
	ctx := r.Context()
	m := make(map[string]interface{})
	if r.Method != http.MethodPost {
		writeJsonError(w, r, http.StatusMethodNotAllowed, errors.New("Only submit via POST!"))
		return
	}

	debug("parsing upload file...")
	bytesBuffer := bufPool.Get().(*bytes.Buffer)
	defer bufPool.Put(bytesBuffer)
	pu, pe := needle.ParseUpload(r, fileSizeLimitBytes, bytesBuffer)
	if pe != nil {
		writeJsonError(w, r, http.StatusBadRequest, pe)
		return
	}

	debug("assigning file id for", pu.FileName)
	r.ParseForm()
	count := uint64(1)
	if r.FormValue("count") != "" {
		count, pe = strconv.ParseUint(r.FormValue("count"), 10, 32)
		if pe != nil {
			writeJsonError(w, r, http.StatusBadRequest, pe)
			return
		}
	}
	ar := &operation.VolumeAssignRequest{
		Count:            count,
		DataCenter:       r.FormValue("dataCenter"),
		Rack:             r.FormValue("rack"),
		Replication:      r.FormValue("replication"),
		Collection:       r.FormValue("collection"),
		Ttl:              r.FormValue("ttl"),
		DiskType:         r.FormValue("disk"),
		ExpectedDataSize: uint64(max(int64(0), int64(pu.OriginalDataSize))),
	}
	assignResult, ae := operation.Assign(ctx, masterFn, grpcDialOption, ar)
	if ae != nil {
		writeJsonError(w, r, http.StatusInternalServerError, ae)
		return
	}

	url := "http://" + assignResult.Url + "/" + assignResult.Fid
	if pu.ModifiedTime != 0 {
		url = url + "?ts=" + strconv.FormatUint(pu.ModifiedTime, 10)
	}

	debug("upload file to store", url)
	uploadOption := &operation.UploadOption{
		UploadUrl:         url,
		Filename:          pu.FileName,
		Cipher:            false,
		IsInputCompressed: pu.IsGzipped,
		MimeType:          pu.MimeType,
		PairMap:           pu.PairMap,
		Jwt:               assignResult.Auth,
	}
	uploader, err := operation.NewUploader()
	if err != nil {
		writeJsonError(w, r, http.StatusInternalServerError, err)
		return
	}
	uploadResult, err := uploader.UploadData(ctx, pu.Data, uploadOption)
	if err != nil {
		writeJsonError(w, r, http.StatusInternalServerError, err)
		return
	}

	m["fileName"] = pu.FileName
	m["fid"] = assignResult.Fid
	m["fileUrl"] = assignResult.PublicUrl + "/" + assignResult.Fid
	m["size"] = pu.OriginalDataSize
	m["eTag"] = uploadResult.ETag
	writeJsonQuiet(w, r, http.StatusCreated, m)
	return
}

func parseURLPath(path string) (vid, fid, filename, ext string, isVolumeIdOnly bool) {
	switch strings.Count(path, "/") {
	case 3:
		parts := strings.Split(path, "/")
		vid, fid, filename = parts[1], parts[2], parts[3]
		ext = filepath.Ext(filename)
	case 2:
		parts := strings.Split(path, "/")
		vid, fid = parts[1], parts[2]
		dotIndex := strings.LastIndex(fid, ".")
		if dotIndex > 0 {
			ext = fid[dotIndex:]
			fid = fid[0:dotIndex]
		}
	default:
		sepIndex := strings.LastIndex(path, "/")
		commaIndex := strings.LastIndex(path[sepIndex:], ",")
		if commaIndex <= 0 {
			vid, isVolumeIdOnly = path[sepIndex+1:], true
			return
		}
		dotIndex := strings.LastIndex(path[sepIndex:], ".")
		vid = path[sepIndex+1 : commaIndex]
		fid = path[commaIndex+1:]
		ext = ""
		if dotIndex > 0 {
			fid = path[commaIndex+1 : dotIndex]
			ext = path[dotIndex:]
		}
	}
	return
}

var StaticFS fs.FS

func handleStaticResources(defaultMux *http.ServeMux) {
	defaultMux.Handle("/favicon.ico", http.FileServer(http.FS(StaticFS)))
	defaultMux.Handle("/seaweedfsstatic/", http.StripPrefix("/seaweedfsstatic", http.FileServer(http.FS(StaticFS))))
}

func handleStaticResources2(r *mux.Router) {
	r.Handle("/favicon.ico", http.FileServer(http.FS(StaticFS)))
	r.PathPrefix("/seaweedfsstatic/").Handler(http.StripPrefix("/seaweedfsstatic", http.FileServer(http.FS(StaticFS))))
}

func AdjustPassthroughHeaders(w http.ResponseWriter, r *http.Request, filename string) {
	// Apply S3 passthrough headers from query parameters
	// AWS S3 supports overriding response headers via query parameters like:
	// ?response-cache-control=no-cache&response-content-type=application/json
	for queryParam, headerValue := range r.URL.Query() {
		if normalizedHeader, ok := s3_constants.PassThroughHeaders[strings.ToLower(queryParam)]; ok && len(headerValue) > 0 {
			w.Header().Set(normalizedHeader, headerValue[0])
		}
	}
	adjustHeaderContentDisposition(w, r, filename)
}
func adjustHeaderContentDisposition(w http.ResponseWriter, r *http.Request, filename string) {
	if contentDisposition := w.Header().Get("Content-Disposition"); contentDisposition != "" {
		return
	}
	if filename != "" {
		dispositionType := "inline"
		if r.FormValue("dl") != "" {
			if dl, _ := strconv.ParseBool(r.FormValue("dl")); dl {
				dispositionType = "attachment"
			}
		}
		// Use mime.FormatMediaType for RFC 6266 compliant Content-Disposition,
		// properly handling non-ASCII characters and special characters
		w.Header().Set("Content-Disposition", mime.FormatMediaType(dispositionType, map[string]string{"filename": filename}))
	}
}

// responseBodyTracker records how many bytes have reached the ResponseWriter.
// Bytes still sitting in the pooled bufio.Writer do not count: the status line
// is not committed until the buffer flushes.
type responseBodyTracker struct {
	http.ResponseWriter
	written int64
}

func (t *responseBodyTracker) Write(p []byte) (int, error) {
	n, err := t.ResponseWriter.Write(p)
	t.written += int64(n)
	return n, err
}

// ifRangeMatches reports whether an If-Range validator still names the
// representation described by header (RFC 9110 13.1.5): an entity tag by
// strong comparison, or a date equal to Last-Modified.
func ifRangeMatches(ifRange string, header http.Header) bool {
	ifRange = strings.TrimSpace(ifRange)
	if ifRange == "" {
		return true
	}
	if strings.HasPrefix(ifRange, "\"") || strings.HasPrefix(ifRange, "W/") {
		etag := header.Get("ETag")
		return etag != "" && !strings.HasPrefix(etag, "W/") && ifRange == etag
	}
	date, err := http.ParseTime(ifRange)
	if err != nil {
		return false
	}
	lastModified, err := http.ParseTime(header.Get("Last-Modified"))
	return err == nil && date.Equal(lastModified)
}

func ProcessRangeRequest(r *http.Request, w http.ResponseWriter, totalSize int64, mimeType string, prepareWriteFn func(offset int64, size int64) (filer.DoStreamContent, error)) error {
	rangeReq := r.Header.Get("Range")
	// A Range whose If-Range no longer matches is ignored and the whole content
	// is sent, so a resumed download restarts instead of mixing two versions.
	if rangeReq != "" && !ifRangeMatches(r.Header.Get("If-Range"), w.Header()) {
		rangeReq = ""
	}
	sink := &responseBodyTracker{ResponseWriter: w}
	bufferedWriter := writePool.Get().(*bufio.Writer)
	bufferedWriter.Reset(sink)
	discardBuffered := false
	defer func() {
		if discardBuffered {
			bufferedWriter.Reset(io.Discard)
		} else {
			bufferedWriter.Flush()
		}
		writePool.Put(bufferedWriter)
	}()

	if rangeReq == "" {
		w.Header().Set("Content-Length", strconv.FormatInt(totalSize, 10))
		writeFn, err := prepareWriteFn(0, totalSize)
		if err != nil {
			writePrepareWriteFnErr(w, err)
			return fmt.Errorf("ProcessRangeRequest: %w", err)
		}
		if err = writeFn(bufferedWriter); err != nil {
			glog.Errorf("ProcessRangeRequest: %v", err)
			// Drop the unflushed tail: flushing it would finish a 200 whose
			// Content-Length is already set, delivering corrupt bytes as a
			// complete body.
			discardBuffered = true
			if sink.written > 0 {
				panic(http.ErrAbortHandler)
			}
			w.Header().Del("Content-Length")
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return fmt.Errorf("ProcessRangeRequest: %w", err)
		}
		return nil
	}

	//the rest is dealing with partial content request
	//mostly copy from src/pkg/net/http/fs.go
	ranges, err := parseRange(rangeReq, totalSize)
	if err != nil {
		glog.Errorf("ProcessRangeRequest headers: %+v err: %v", w.Header(), err)
		if err == errNoOverlap {
			w.Header().Set("Content-Range", fmt.Sprintf("bytes */%d", totalSize))
		}
		http.Error(w, err.Error(), http.StatusRequestedRangeNotSatisfiable)
		return fmt.Errorf("ProcessRangeRequest header: %w", err)
	}
	if sumRangesSize(ranges) > totalSize {
		// The total number of bytes in all the ranges
		// is larger than the size of the file by
		// itself, so this is probably an attack, or a
		// dumb client.  Ignore the range request.
		return nil
	}
	if len(ranges) == 0 {
		return nil
	}
	if len(ranges) == 1 {
		// RFC 2616, Section 14.16:
		// "When an HTTP message includes the content of a single
		// range (for example, a response to a request for a
		// single range, or to a request for a set of ranges
		// that overlap without any holes), this content is
		// transmitted with a Content-Range header, and a
		// Content-Length header showing the number of bytes
		// actually transferred.
		// ...
		// A response to a request for a single range MUST NOT
		// be sent using the multipart/byteranges media type."
		ra := ranges[0]
		w.Header().Set("Content-Length", strconv.FormatInt(ra.length, 10))
		w.Header().Set("Content-Range", ra.contentRange(totalSize))

		writeFn, err := prepareWriteFn(ra.start, ra.length)
		if err != nil {
			writePrepareWriteFnErr(w, err)
			return fmt.Errorf("ProcessRangeRequest: %w", err)
		}
		w.WriteHeader(http.StatusPartialContent)
		err = writeFn(bufferedWriter)
		if err != nil {
			glog.Errorf("ProcessRangeRequest range[0]: %+v err: %v", w.Header(), err)
			// WriteHeader was already called: drop the unflushed tail and
			// abort so the client does not read corrupt bytes as a full body.
			discardBuffered = true
			panic(http.ErrAbortHandler)
		}
		return nil
	}

	// process multiple ranges
	writeFnByRange := make(map[int](func(writer io.Writer) error))

	for i, ra := range ranges {
		if ra.start > totalSize {
			http.Error(w, "Out of Range", http.StatusRequestedRangeNotSatisfiable)
			return fmt.Errorf("out of range: %w", err)
		}
		writeFn, err := prepareWriteFn(ra.start, ra.length)
		if err != nil {
			writePrepareWriteFnErr(w, err)
			return fmt.Errorf("ProcessRangeRequest range[%d]: %w", i, err)
		}
		writeFnByRange[i] = writeFn
	}
	sendSize := rangesMIMESize(ranges, mimeType, totalSize)
	pr, pw := io.Pipe()
	mw := multipart.NewWriter(pw)
	w.Header().Set("Content-Type", "multipart/byteranges; boundary="+mw.Boundary())
	sendContent := pr
	defer pr.Close() // cause writing goroutine to fail and exit if CopyN doesn't finish.
	go func() {
		for i, ra := range ranges {
			part, e := mw.CreatePart(ra.mimeHeader(mimeType, totalSize))
			if e != nil {
				pw.CloseWithError(e)
				return
			}
			writeFn := writeFnByRange[i]
			if writeFn == nil {
				pw.CloseWithError(e)
				return
			}
			if e = writeFn(part); e != nil {
				pw.CloseWithError(e)
				return
			}
		}
		mw.Close()
		pw.Close()
	}()
	if w.Header().Get("Content-Encoding") == "" {
		w.Header().Set("Content-Length", strconv.FormatInt(sendSize, 10))
	}
	w.WriteHeader(http.StatusPartialContent)
	if _, err := io.CopyN(bufferedWriter, sendContent, sendSize); err != nil {
		glog.Errorf("ProcessRangeRequest err: %v", err)
		// WriteHeader was already called: drop the unflushed tail and abort.
		discardBuffered = true
		panic(http.ErrAbortHandler)
	}
	return nil
}

// CleanPathHandler serves a request whose path is not canonical ("//", "." or
// ".." segments) at the cleaned path instead of letting http.ServeMux redirect
// to it. ServeMux builds that redirect from the already percent-encoded path, so
// the Location header is encoded twice (golang/go#79897): a client following it
// re-sends "/负极全景" as "/%25E8%25B4%259F...", and the filer then stores a
// directory literally named "%E8%B4%9F...". Cleaning here mirrors the path
// ServeMux would have redirected to, so the decoded name reaches the handler.
func CleanPathHandler(h http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		escaped := r.URL.EscapedPath()
		if cleaned := cleanPath(escaped); cleaned != escaped {
			if p, err := url.PathUnescape(cleaned); err == nil {
				r2 := new(http.Request)
				*r2 = *r
				r2.URL = new(url.URL)
				*r2.URL = *r.URL
				r2.URL.Path, r2.URL.RawPath = p, cleaned
				// PostHandler picks storage rules and the bucket from RequestURI, so
				// keep it in step with the path the entry is written to.
				r2.RequestURI = r2.URL.RequestURI()
				r = r2
			}
		}
		h.ServeHTTP(w, r)
	})
}

// cleanPath is the canonical form http.ServeMux redirects to: path.Clean plus
// the trailing slash, which the filer relies on to tell a directory from a file.
func cleanPath(p string) string {
	if p == "" {
		return "/"
	}
	if p[0] != '/' {
		p = "/" + p
	}
	np := path.Clean(p)
	if p[len(p)-1] == '/' && np != "/" {
		np += "/"
	}
	return np
}

func requestIDMiddleware(h http.HandlerFunc) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		request_id.Middleware(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			ctx := metadata.NewOutgoingContext(r.Context(),
				metadata.New(map[string]string{
					request_id.AmzRequestIDHeader: request_id.Get(r.Context()),
				}))
			h(w, r.WithContext(ctx))
		})).ServeHTTP(w, r)
	}
}