147 lines
4 KiB
Go
147 lines
4 KiB
Go
package handler
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"io"
|
|
"net/http"
|
|
"strconv"
|
|
"time"
|
|
|
|
"git.frostfs.info/TrueCloudLab/frostfs-http-gw/internal/data"
|
|
"git.frostfs.info/TrueCloudLab/frostfs-http-gw/internal/logs"
|
|
"git.frostfs.info/TrueCloudLab/frostfs-http-gw/internal/service/frostfs"
|
|
"git.frostfs.info/TrueCloudLab/frostfs-http-gw/response"
|
|
"git.frostfs.info/TrueCloudLab/frostfs-http-gw/utils"
|
|
"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/object"
|
|
oid "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/object/id"
|
|
"github.com/valyala/fasthttp"
|
|
"go.uber.org/zap"
|
|
)
|
|
|
|
type readCloser struct {
|
|
io.Reader
|
|
io.Closer
|
|
}
|
|
|
|
// initializes io.Reader with the limited size and detects Content-Type from it.
|
|
// Returns r's error directly. Also returns the processed data.
|
|
func readContentType(maxSize uint64, rInit func(uint64) (io.Reader, error)) (string, []byte, error) {
|
|
if maxSize > sizeToDetectType {
|
|
maxSize = sizeToDetectType
|
|
}
|
|
|
|
buf := make([]byte, maxSize) // maybe sync-pool the slice?
|
|
|
|
r, err := rInit(maxSize)
|
|
if err != nil {
|
|
return "", nil, err
|
|
}
|
|
|
|
n, err := r.Read(buf)
|
|
if err != nil && err != io.EOF {
|
|
return "", nil, err
|
|
}
|
|
|
|
buf = buf[:n]
|
|
|
|
return http.DetectContentType(buf), buf, err // to not lose io.EOF
|
|
}
|
|
|
|
type getPayloadParams struct {
|
|
obj *frostfs.Object
|
|
req request
|
|
bktinfo *data.BucketInfo
|
|
attrs map[string]string
|
|
}
|
|
|
|
func (h *Handler) receiveFile(ctx context.Context, req request, objAddress oid.Address, bktInfo *data.BucketInfo) {
|
|
var (
|
|
shouldDownload = req.QueryArgs().GetBool("download")
|
|
start = time.Now()
|
|
)
|
|
|
|
prm := frostfs.PrmObjectGet{
|
|
PrmAuth: frostfs.PrmAuth{
|
|
BearerToken: bearerToken(ctx),
|
|
},
|
|
Address: objAddress,
|
|
}
|
|
|
|
rObj, err := h.frostfs.GetObject(ctx, prm)
|
|
if err != nil {
|
|
req.handleFrostFSErr(err, start)
|
|
return
|
|
}
|
|
|
|
// we can't close reader in this function, so how to do it?
|
|
|
|
attrs := makeAttributesMap(rObj.Header.Attributes())
|
|
req.setAttributes(attrs)
|
|
|
|
req.setIDs(rObj.Header)
|
|
req.setDisposition(shouldDownload, attrs[object.AttributeFileName])
|
|
|
|
if err = req.setTimestamp(attrs[object.AttributeTimestamp]); err != nil {
|
|
req.log.Error(logs.CouldntParseCreationDate,
|
|
zap.String("val", attrs[object.AttributeTimestamp]),
|
|
zap.Error(err))
|
|
response.Error(req.RequestCtx, "failed to convert timestamp: "+err.Error(), fasthttp.StatusInternalServerError)
|
|
}
|
|
|
|
payloadParams := getPayloadParams{
|
|
obj: rObj,
|
|
req: req,
|
|
bktinfo: bktInfo,
|
|
attrs: attrs,
|
|
}
|
|
|
|
payload, payloadSize, err := h.getPayload(payloadParams)
|
|
if err != nil {
|
|
req.handleFrostFSErr(err, start)
|
|
return
|
|
}
|
|
req.Response.Header.Set(fasthttp.HeaderContentLength, strconv.FormatUint(payloadSize, 10))
|
|
|
|
contentType := attrs[object.AttributeContentType]
|
|
if len(contentType) == 0 {
|
|
// determine the Content-Type from the payload head
|
|
var payloadHead []byte
|
|
|
|
contentType, payloadHead, err = readContentType(payloadSize, func(uint64) (io.Reader, error) {
|
|
return payload, nil
|
|
})
|
|
if err != nil && err != io.EOF {
|
|
req.log.Error(logs.CouldNotDetectContentTypeFromPayload, zap.Error(err))
|
|
response.Error(req.RequestCtx, "could not detect Content-Type from payload: "+err.Error(), fasthttp.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
// reset payload reader since a part of the data has been read
|
|
var headReader io.Reader = bytes.NewReader(payloadHead)
|
|
|
|
if err != io.EOF { // otherwise, we've already read full payload
|
|
headReader = io.MultiReader(headReader, payload)
|
|
}
|
|
|
|
// note: we could do with io.Reader, but SetBodyStream below closes body stream
|
|
// if it implements io.Closer and that's useful for us.
|
|
payload = readCloser{headReader, payload}
|
|
}
|
|
req.SetContentType(contentType)
|
|
|
|
req.Response.SetBodyStream(payload, int(payloadSize))
|
|
}
|
|
|
|
func makeAttributesMap(attrs []object.Attribute) map[string]string {
|
|
attributes := make(map[string]string)
|
|
for _, attr := range attrs {
|
|
if !isValidToken(attr.Key()) || !isValidValue(attr.Value()) {
|
|
continue
|
|
}
|
|
key := utils.BackwardTransformIfSystem(attr.Key())
|
|
|
|
attributes[key] = attr.Value()
|
|
}
|
|
return attributes
|
|
}
|