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.

9.7 KB
Raw Blame
package lance

import (
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"strconv"
	"strings"

	"github.com/gorilla/mux"
	"github.com/seaweedfs/seaweedfs/weed/glog"
	"github.com/seaweedfs/seaweedfs/weed/pb/filer_pb"
	"github.com/seaweedfs/seaweedfs/weed/s3api/s3_constants"
	"github.com/seaweedfs/seaweedfs/weed/s3api/s3tables"
)

const defaultPageSize = 1000

// manager is the S3 Tables manager a request runs through: a cluster process,
// authenticated by the cluster token alone, has no identity of its own and is
// trusted; every other caller is checked against its grants.
func (s *Server) manager(r *http.Request) *s3tables.Manager {
	if s3_constants.GetIdentityNameFromContext(r) == "" && isTrustedCaller(r.Context()) {
		return s.internal
	}
	return s.tablesManager
}

// execute runs one S3 Tables operation as the request's authenticated caller.
func (s *Server) execute(r *http.Request, operation string, req, resp interface{}) error {
	identityName := s3_constants.GetIdentityNameFromContext(r)
	return s.filerClient.WithFilerClient(false, func(client filer_pb.SeaweedFilerClient) error {
		return s.manager(r).Execute(r.Context(), s3tables.NewManagerClient(client), operation, req, resp, identityName)
	})
}

// executeInternal runs one S3 Tables operation through the trusted manager —
// the caller's catalog grants must not gate an internal resolution that the
// caller's own vector permission already authorized.
func (s *Server) executeInternal(r *http.Request, operation string, req, resp interface{}) error {
	return s.filerClient.WithFilerClient(false, func(client filer_pb.SeaweedFilerClient) error {
		return s.internal.Execute(r.Context(), s3tables.NewManagerClient(client), operation, req, resp, "")
	})
}

func bucketARN(bucket string) string {
	arn, _ := s3tables.BuildBucketARN(s3tables.DefaultRegion, s3_constants.AccountAdminId, bucket)
	return arn
}

// maxRequestBody bounds what one call can make the catalog hold. Every request
// this surface takes is a small JSON envelope; the largest carries a set of
// properties, not data.
const maxRequestBody = 4 << 20

// decodeBody reads an optional JSON request body. Every Lance operation carries
// one, but the fields that matter are also in the route, so an empty body is
// not an error.
func decodeBody(r *http.Request, into interface{}) error {
	body, err := io.ReadAll(io.LimitReader(r.Body, maxRequestBody+1))
	if err != nil {
		return fmt.Errorf("read request body: %w", err)
	}
	if len(body) > maxRequestBody {
		return fmt.Errorf("request body is larger than %d bytes", maxRequestBody)
	}
	if len(strings.TrimSpace(string(body))) == 0 {
		return nil
	}
	if err := json.Unmarshal(body, into); err != nil {
		return fmt.Errorf("invalid request body: %w", err)
	}
	return nil
}

// routeIdentifier parses the {id} route variable, writing the error response
// itself when the identifier is malformed.
func routeIdentifier(w http.ResponseWriter, r *http.Request) (identifier, string, bool) {
	delimiter := requestDelimiter(r)
	id, err := parseIdentifier(mux.Vars(r)["id"], delimiter)
	if err != nil {
		writeError(w, r, http.StatusBadRequest, codeInvalidInput, err.Error())
		return nil, delimiter, false
	}
	return id, delimiter, true
}

// checkBodyIdentifier enforces the spec rule that a route and a body naming
// different objects is a bad request rather than a silent preference.
func checkBodyIdentifier(w http.ResponseWriter, r *http.Request, id identifier, body []string) bool {
	if id.matchesBody(body) {
		return true
	}
	writeError(w, r, http.StatusBadRequest, codeInvalidInput,
		"the identifier in the request body does not match the one in the route")
	return false
}

func pageSize(r *http.Request) int {
	if raw := r.URL.Query().Get("limit"); raw != "" {
		if parsed, err := strconv.Atoi(raw); err == nil && parsed > 0 {
			return parsed
		}
	}
	return defaultPageSize
}

func boolQuery(r *http.Request, name string) bool {
	value, err := strconv.ParseBool(r.URL.Query().Get(name))
	return err == nil && value
}

// wants resolves a tri-state request flag: the query parameter the REST spec
// adds, else the body field, else the implementation's own choice.
func wants(r *http.Request, name string, body *bool) bool {
	if boolQuery(r, name) {
		return true
	}
	return body != nil && *body
}

// tableLocation is where a table's dataset lives when the caller does not name
// a location. It mirrors the Iceberg catalog's layout so both catalogs put a
// table of the same name in the same place.
func tableLocation(bucket string, ns []string, name string) string {
	return fmt.Sprintf("s3://%s/%s/%s", bucket, strings.Join(ns, "."), name)
}

// confineLocation rejects a client-supplied table location that does not resolve
// inside the caller's own bucket, the way the Iceberg gateway confines the same
// field. The location feeds TableDataDirFromMetadataLocation, which joins it
// under /buckets and collapses any "../" segments; an unconfined location lets a
// marker write escape into another tenant's namespace.
func confineLocation(bucket, location string) error {
	rest, ok := strings.CutPrefix(location, "s3://")
	if !ok {
		return fmt.Errorf("location must be an s3:// URI")
	}
	name, keys, _ := strings.Cut(rest, "/")
	if name != bucket {
		return fmt.Errorf("location must be within bucket %s", bucket)
	}
	for _, segment := range strings.Split(keys, "/") {
		switch {
		case segment == "." || segment == "..":
			return fmt.Errorf("location must not contain a path traversal segment")
		case strings.ContainsAny(segment, "\\\x00"):
			return fmt.Errorf("location contains an invalid character")
		}
	}
	return nil
}

// storageOptions builds the object_store settings a Lance client needs to reach
// the dataset. The key names are the aws_-prefixed forms Lance clients pass
// through to object_store.
func (s *Server) storageOptions(r *http.Request, bucket, location string, vend bool, canWrite func() bool) (map[string]string, error) {
	options := map[string]string{}
	if s.s3Endpoint != "" {
		options["aws_endpoint"] = s.s3Endpoint
		if strings.HasPrefix(s.s3Endpoint, "http://") {
			// object_store refuses a plaintext endpoint unless told to allow it,
			// and the resulting failure reads like a credential problem.
			options["allow_http"] = "true"
		}
	}
	if s.s3Region != "" {
		options["aws_region"] = s.s3Region
	}
	if !s.authEnabled() {
		// The S3 port takes unsigned requests, and a client with no
		// credentials of its own would otherwise fail looking for some.
		options["aws_skip_signature"] = "true"
	}

	if !vend || s.credentialVendor == nil {
		return options, nil
	}

	principal := s3_constants.GetIdentityNameFromContext(r)
	// A cluster process reaches the table's files on the filers and volume
	// servers itself; it has no principal and needs no S3 credentials.
	if principal == "" && isTrustedCaller(r.Context()) {
		return options, nil
	}
	credentials, err := s.credentialVendor.VendTableCredentials(r.Context(), principal, bucket, locationPrefix(location), canWrite == nil || !canWrite())
	if err != nil {
		return nil, err
	}
	if credentials == nil {
		return options, nil
	}
	options["aws_access_key_id"] = credentials.AccessKeyID
	options["aws_secret_access_key"] = credentials.SecretAccessKey
	if credentials.SessionToken != "" {
		options["aws_session_token"] = credentials.SessionToken
	}
	if !credentials.Expiration.IsZero() {
		options["expires_at_millis"] = strconv.FormatInt(credentials.Expiration.UnixMilli(), 10)
	}
	return options, nil
}

// mayUpdateTable reports whether the caller may commit to the table the
// credentials would cover, the same gate the Iceberg catalog applies so a
// read-only caller never gets write-capable storage_options.
func (s *Server) mayUpdateTable(r *http.Request, bucket string, ns []string, name string) bool {
	if !s.mayWriteNamespace(r, bucket, ns) {
		return false
	}
	req := &s3tables.UpdateTableRequest{
		TableBucketARN: bucketARN(bucket),
		Namespace:      ns,
		Name:           name,
	}
	identityName := s3_constants.GetIdentityNameFromContext(r)
	err := s.filerClient.WithFilerClient(false, func(client filer_pb.SeaweedFilerClient) error {
		return s.tablesManager.AuthorizeUpdateTable(r.Context(), s3tables.NewManagerClient(client), req, identityName)
	})
	if err != nil {
		glog.V(1).Infof("lance: UpdateTable check for %s/%s failed, vending read-only: %v", bucket, name, err)
	}
	return err == nil
}

// authorizeUpdateTable checks the grant a change to the table's catalog state
// needs; a cluster process goes through the trusted manager.
func (s *Server) authorizeUpdateTable(r *http.Request, bucket string, ns []string, name string) error {
	req := &s3tables.UpdateTableRequest{
		TableBucketARN: bucketARN(bucket),
		Namespace:      ns,
		Name:           name,
	}
	identityName := s3_constants.GetIdentityNameFromContext(r)
	return s.filerClient.WithFilerClient(false, func(client filer_pb.SeaweedFilerClient) error {
		return s.manager(r).AuthorizeUpdateTable(r.Context(), s3tables.NewManagerClient(client), req, identityName)
	})
}

// mayWriteNamespace keeps the vector namespace of a vector bucket out of reach
// of s3tables grants: its index data is written only by trusted callers, and
// the vector bucket policy gates everyone else through S3 Vectors.
func (s *Server) mayWriteNamespace(r *http.Request, bucket string, ns []string) bool {
	if isTrustedCaller(r.Context()) {
		return true
	}
	err := s.tablesManager.CheckVectorNamespaceWrite(r.Context(), s.filerClient, bucket, ns)
	if err != nil {
		glog.V(1).Infof("lance: %s/%s is read-only to this caller: %v", bucket, strings.Join(ns, "."), err)
	}
	return err == nil
}

// locationPrefix strips the s3://bucket/ part of a location, leaving the key
// prefix a credential is scoped to.
func locationPrefix(location string) string {
	trimmed := strings.TrimPrefix(location, "s3://")
	if _, prefix, found := strings.Cut(trimmed, "/"); found {
		return prefix
	}
	return ""
}