139 lines
3.7 KiB
Go
139 lines
3.7 KiB
Go
package handler
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"net/http"
|
|
"strconv"
|
|
"strings"
|
|
|
|
"git.frostfs.info/TrueCloudLab/frostfs-s3-gw/api"
|
|
"git.frostfs.info/TrueCloudLab/frostfs-s3-gw/api/data"
|
|
apierr "git.frostfs.info/TrueCloudLab/frostfs-s3-gw/api/errors"
|
|
"git.frostfs.info/TrueCloudLab/frostfs-s3-gw/api/layer"
|
|
"git.frostfs.info/TrueCloudLab/frostfs-s3-gw/api/middleware"
|
|
"git.frostfs.info/TrueCloudLab/frostfs-s3-gw/internal/logs"
|
|
cid "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/container/id"
|
|
"go.uber.org/zap"
|
|
)
|
|
|
|
func (h *handler) reqLogger(ctx context.Context) *zap.Logger {
|
|
reqLogger := middleware.GetReqLog(ctx)
|
|
if reqLogger != nil {
|
|
return reqLogger
|
|
}
|
|
return h.log
|
|
}
|
|
|
|
func (h *handler) logAndSendError(ctx context.Context, w http.ResponseWriter, logText string, reqInfo *middleware.ReqInfo, err error, additional ...zap.Field) {
|
|
err = handleDeleteMarker(w, err)
|
|
if code, wrErr := middleware.WriteErrorResponse(w, reqInfo, apierr.TransformToS3Error(err)); wrErr != nil {
|
|
additional = append(additional, zap.NamedError("write_response_error", wrErr))
|
|
} else {
|
|
additional = append(additional, zap.Int("status", code))
|
|
}
|
|
fields := []zap.Field{
|
|
zap.String("method", reqInfo.API),
|
|
zap.String("bucket", reqInfo.BucketName),
|
|
zap.String("object", reqInfo.ObjectName),
|
|
zap.String("description", logText),
|
|
zap.String("user", reqInfo.User),
|
|
zap.Error(err)}
|
|
fields = append(fields, additional...)
|
|
h.reqLogger(ctx).Error(logs.RequestFailed, fields...)
|
|
}
|
|
|
|
func handleDeleteMarker(w http.ResponseWriter, err error) error {
|
|
var target layer.DeleteMarkerError
|
|
if !errors.As(err, &target) {
|
|
return err
|
|
}
|
|
|
|
w.Header().Set(api.AmzDeleteMarker, "true")
|
|
return fmt.Errorf("%w: %s", apierr.GetAPIError(target.ErrorCode), err)
|
|
}
|
|
|
|
func (h *handler) ResolveBucket(ctx context.Context, bucket string) (*data.BucketInfo, error) {
|
|
return h.getBucketInfo(ctx, bucket)
|
|
}
|
|
|
|
func (h *handler) ResolveCID(ctx context.Context, bucket string) (cid.ID, error) {
|
|
return h.obj.ResolveCID(ctx, bucket)
|
|
}
|
|
|
|
func (h *handler) getBucketInfo(ctx context.Context, bucket string) (*data.BucketInfo, error) {
|
|
if err := checkBucketName(bucket); err != nil {
|
|
return nil, err
|
|
}
|
|
return h.obj.GetBucketInfo(ctx, bucket)
|
|
}
|
|
|
|
func (h *handler) getBucketAndCheckOwner(r *http.Request, bucket string, header ...string) (*data.BucketInfo, error) {
|
|
bktInfo, err := h.getBucketInfo(r.Context(), bucket)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var expected string
|
|
if len(header) == 0 {
|
|
expected = r.Header.Get(api.AmzExpectedBucketOwner)
|
|
} else {
|
|
expected = r.Header.Get(header[0])
|
|
}
|
|
|
|
if len(expected) == 0 {
|
|
return bktInfo, nil
|
|
}
|
|
|
|
return bktInfo, checkOwner(bktInfo, expected)
|
|
}
|
|
|
|
func (h *handler) getPutPayloadSize(r *http.Request) uint64 {
|
|
decodeContentSize := r.Header.Get(api.AmzDecodedContentLength)
|
|
decodedSize, err := strconv.Atoi(decodeContentSize)
|
|
if err != nil {
|
|
if r.ContentLength >= 0 {
|
|
return uint64(r.ContentLength)
|
|
}
|
|
return 0
|
|
}
|
|
|
|
return uint64(decodedSize)
|
|
}
|
|
|
|
func parseRange(s string) (*layer.RangeParams, error) {
|
|
if s == "" {
|
|
return nil, nil
|
|
}
|
|
|
|
prefix := "bytes="
|
|
|
|
if !strings.HasPrefix(s, prefix) {
|
|
return nil, apierr.GetAPIError(apierr.ErrInvalidRange)
|
|
}
|
|
|
|
s = strings.TrimPrefix(s, prefix)
|
|
|
|
valuesStr := strings.Split(s, "-")
|
|
if len(valuesStr) != 2 {
|
|
return nil, apierr.GetAPIError(apierr.ErrInvalidRange)
|
|
}
|
|
|
|
values := make([]uint64, 0, len(valuesStr))
|
|
for _, v := range valuesStr {
|
|
num, err := strconv.ParseUint(v, 10, 64)
|
|
if err != nil {
|
|
return nil, apierr.GetAPIError(apierr.ErrInvalidRange)
|
|
}
|
|
values = append(values, num)
|
|
}
|
|
if values[0] > values[1] {
|
|
return nil, apierr.GetAPIError(apierr.ErrInvalidRange)
|
|
}
|
|
|
|
return &layer.RangeParams{
|
|
Start: values[0],
|
|
End: values[1],
|
|
}, nil
|
|
}
|