seaweedfs/weed/operation/upload_content.go

278 lines
8.6 KiB
Go
Raw Normal View History

2012-09-21 00:58:29 +00:00
package operation
import (
2012-09-26 10:27:10 +00:00
"bytes"
"encoding/json"
"fmt"
2012-09-26 10:27:10 +00:00
"io"
"io/ioutil"
"mime"
2012-09-26 10:27:10 +00:00
"mime/multipart"
"net/http"
"net/textproto"
"path/filepath"
2020-09-09 18:21:23 +00:00
"runtime/debug"
"strings"
"time"
"github.com/chrislusf/seaweedfs/weed/glog"
"github.com/chrislusf/seaweedfs/weed/pb/filer_pb"
"github.com/chrislusf/seaweedfs/weed/security"
2019-04-19 04:43:36 +00:00
"github.com/chrislusf/seaweedfs/weed/util"
"github.com/valyala/bytebufferpool"
2012-09-21 00:58:29 +00:00
)
type UploadResult struct {
Name string `json:"name,omitempty"`
Size uint32 `json:"size,omitempty"`
Error string `json:"error,omitempty"`
ETag string `json:"eTag,omitempty"`
CipherKey []byte `json:"cipherKey,omitempty"`
Mime string `json:"mime,omitempty"`
Gzip uint32 `json:"gzip,omitempty"`
ContentMd5 string `json:"contentMd5,omitempty"`
2021-03-07 19:26:15 +00:00
RetryCount int `json:"-"`
2012-09-21 00:58:29 +00:00
}
func (uploadResult *UploadResult) ToPbFileChunk(fileId string, offset int64) *filer_pb.FileChunk {
2020-08-16 02:55:28 +00:00
fid, _ := filer_pb.ToFileIdObject(fileId)
return &filer_pb.FileChunk{
FileId: fileId,
Offset: offset,
Size: uint64(uploadResult.Size),
Mtime: time.Now().UnixNano(),
ETag: uploadResult.ETag,
CipherKey: uploadResult.CipherKey,
IsCompressed: uploadResult.Gzip > 0,
2020-08-16 02:55:28 +00:00
Fid: fid,
}
}
// HTTPClient interface for testing
type HTTPClient interface {
Do(req *http.Request) (*http.Response, error)
}
2014-03-12 21:07:01 +00:00
var (
HttpClient HTTPClient
2014-03-12 21:07:01 +00:00
)
func init() {
HttpClient = &http.Client{Transport: &http.Transport{
MaxIdleConns: 1024,
MaxIdleConnsPerHost: 1024,
}}
2014-03-12 21:07:01 +00:00
}
var fileNameEscaper = strings.NewReplacer(`\`, `\\`, `"`, `\"`)
// Upload sends a POST request to a volume server to upload the content with adjustable compression level
func UploadData(uploadUrl string, filename string, cipher bool, data []byte, isInputCompressed bool, mtype string, pairMap map[string]string, jwt security.EncodedJwt) (uploadResult *UploadResult, err error) {
2020-08-12 03:30:11 +00:00
uploadResult, err = retriedUploadData(uploadUrl, filename, cipher, data, isInputCompressed, mtype, pairMap, jwt)
return
}
// Upload sends a POST request to a volume server to upload the content with fast compression
func Upload(uploadUrl string, filename string, cipher bool, reader io.Reader, isInputCompressed bool, mtype string, pairMap map[string]string, jwt security.EncodedJwt) (uploadResult *UploadResult, err error, data []byte) {
uploadResult, err, data = doUpload(uploadUrl, filename, cipher, reader, isInputCompressed, mtype, pairMap, jwt)
return
}
func doUpload(uploadUrl string, filename string, cipher bool, reader io.Reader, isInputCompressed bool, mtype string, pairMap map[string]string, jwt security.EncodedJwt) (uploadResult *UploadResult, err error, data []byte) {
bytesReader, ok := reader.(*util.BytesReader)
if ok {
data = bytesReader.Bytes
} else {
2020-11-03 07:27:54 +00:00
data, err = ioutil.ReadAll(reader)
if err != nil {
err = fmt.Errorf("read input: %v", err)
return
}
2020-03-14 20:55:32 +00:00
}
uploadResult, uploadErr := retriedUploadData(uploadUrl, filename, cipher, data, isInputCompressed, mtype, pairMap, jwt)
2020-03-28 20:41:58 +00:00
return uploadResult, uploadErr, data
}
2020-08-12 03:30:11 +00:00
func retriedUploadData(uploadUrl string, filename string, cipher bool, data []byte, isInputCompressed bool, mtype string, pairMap map[string]string, jwt security.EncodedJwt) (uploadResult *UploadResult, err error) {
2020-10-30 09:16:34 +00:00
for i := 0; i < 3; i++ {
2020-08-12 03:30:11 +00:00
uploadResult, err = doUploadData(uploadUrl, filename, cipher, data, isInputCompressed, mtype, pairMap, jwt)
if err == nil {
2021-03-07 19:45:35 +00:00
uploadResult.RetryCount = i
2020-08-12 03:30:11 +00:00
return
} else {
glog.Warningf("uploading to %s: %v", uploadUrl, err)
}
2021-02-18 04:57:08 +00:00
time.Sleep(time.Millisecond * time.Duration(237*(i+1)))
2020-08-12 03:30:11 +00:00
}
return
}
func doUploadData(uploadUrl string, filename string, cipher bool, data []byte, isInputCompressed bool, mtype string, pairMap map[string]string, jwt security.EncodedJwt) (uploadResult *UploadResult, err error) {
contentIsGzipped := isInputCompressed
shouldGzipNow := false
if !isInputCompressed {
2020-04-14 18:32:31 +00:00
if mtype == "" {
mtype = http.DetectContentType(data)
// println("detect1 mimetype to", mtype)
2020-04-14 18:32:31 +00:00
if mtype == "application/octet-stream" {
mtype = ""
}
}
2020-06-23 16:12:02 +00:00
if shouldBeCompressed, iAmSure := util.IsCompressableFileType(filepath.Base(filename), mtype); iAmSure && shouldBeCompressed {
shouldGzipNow = true
2020-10-24 06:05:55 +00:00
} else if !iAmSure && mtype == "" && len(data) > 16*1024 {
var compressed []byte
compressed, err = util.GzipData(data[0:128])
shouldGzipNow = len(compressed)*10 < 128*9 // can not compress to less than 90%
}
}
var clearDataLen int
// gzip if possible
// this could be double copying
clearDataLen = len(data)
clearData := data
if shouldGzipNow && !cipher {
compressed, compressErr := util.GzipData(data)
// fmt.Printf("data is compressed from %d ==> %d\n", len(data), len(compressed))
if compressErr == nil {
data = compressed
contentIsGzipped = true
}
} else if isInputCompressed {
// just to get the clear data length
clearData, err = util.DecompressData(data)
if err == nil {
clearDataLen = len(clearData)
}
}
if cipher {
// encrypt(gzip(data))
// encrypt
cipherKey := util.GenCipherKey()
encryptedData, encryptionErr := util.Encrypt(clearData, cipherKey)
if encryptionErr != nil {
err = fmt.Errorf("encrypt input: %v", encryptionErr)
return
}
// upload data
uploadResult, err = upload_content(uploadUrl, func(w io.Writer) (err error) {
2020-03-09 04:54:47 +00:00
_, err = w.Write(encryptedData)
return
2020-06-23 16:12:02 +00:00
}, "", false, len(encryptedData), "", nil, jwt)
if uploadResult == nil {
return
}
uploadResult.Name = filename
uploadResult.Mime = mtype
uploadResult.CipherKey = cipherKey
uploadResult.Size = uint32(clearDataLen)
} else {
// upload data
uploadResult, err = upload_content(uploadUrl, func(w io.Writer) (err error) {
2020-03-09 04:54:47 +00:00
_, err = w.Write(data)
return
2020-11-11 20:51:44 +00:00
}, filename, contentIsGzipped, len(data), mtype, pairMap, jwt)
if uploadResult == nil {
return
}
uploadResult.Size = uint32(clearDataLen)
if contentIsGzipped {
uploadResult.Gzip = 1
}
}
return uploadResult, err
}
2020-06-23 16:12:02 +00:00
func upload_content(uploadUrl string, fillBufferFunction func(w io.Writer) error, filename string, isGzipped bool, originalDataSize int, mtype string, pairMap map[string]string, jwt security.EncodedJwt) (*UploadResult, error) {
buf := bytebufferpool.Get()
defer bytebufferpool.Put(buf)
body_writer := multipart.NewWriter(buf)
h := make(textproto.MIMEHeader)
h.Set("Content-Disposition", fmt.Sprintf(`form-data; name="file"; filename="%s"`, fileNameEscaper.Replace(filename)))
h.Set("Idempotency-Key", uploadUrl)
2013-07-29 17:09:36 +00:00
if mtype == "" {
mtype = mime.TypeByExtension(strings.ToLower(filepath.Ext(filename)))
}
if mtype != "" {
h.Set("Content-Type", mtype)
}
if isGzipped {
h.Set("Content-Encoding", "gzip")
}
2014-03-12 22:17:23 +00:00
file_writer, cp_err := body_writer.CreatePart(h)
if cp_err != nil {
glog.V(0).Infoln("error creating form file", cp_err.Error())
return nil, cp_err
2013-02-27 06:54:22 +00:00
}
2014-03-12 22:17:23 +00:00
if err := fillBufferFunction(file_writer); err != nil {
glog.V(0).Infoln("error copying data", err)
2013-02-27 06:54:22 +00:00
return nil, err
}
2013-07-10 07:27:01 +00:00
content_type := body_writer.FormDataContentType()
2014-03-12 22:17:23 +00:00
if err := body_writer.Close(); err != nil {
glog.V(0).Infoln("error closing body", err)
2013-02-27 06:54:22 +00:00
return nil, err
}
req, postErr := http.NewRequest("POST", uploadUrl, bytes.NewReader(buf.Bytes()))
if postErr != nil {
2020-08-26 16:51:20 +00:00
glog.V(1).Infof("create upload request %s: %v", uploadUrl, postErr)
return nil, fmt.Errorf("create upload request %s: %v", uploadUrl, postErr)
}
req.Header.Set("Content-Type", content_type)
for k, v := range pairMap {
req.Header.Set(k, v)
}
2019-02-15 08:09:19 +00:00
if jwt != "" {
req.Header.Set("Authorization", "BEARER "+string(jwt))
}
2020-10-24 07:12:02 +00:00
// print("+")
resp, post_err := HttpClient.Do(req)
2014-03-12 22:17:23 +00:00
if post_err != nil {
2020-09-09 18:21:23 +00:00
glog.Errorf("upload %s %d bytes to %v: %v", filename, originalDataSize, uploadUrl, post_err)
debug.PrintStack()
return nil, fmt.Errorf("upload %s %d bytes to %v: %v", filename, originalDataSize, uploadUrl, post_err)
2012-09-26 10:27:10 +00:00
}
2020-10-24 07:12:02 +00:00
// print("-")
2020-08-24 07:32:44 +00:00
defer util.CloseResponse(resp)
var ret UploadResult
2018-09-23 05:12:21 +00:00
etag := getEtag(resp)
if resp.StatusCode == http.StatusNoContent {
ret.ETag = etag
return &ret, nil
}
2020-08-24 07:32:44 +00:00
resp_body, ra_err := ioutil.ReadAll(resp.Body)
if ra_err != nil {
2020-08-26 16:51:20 +00:00
return nil, fmt.Errorf("read response body %v: %v", uploadUrl, ra_err)
2020-08-24 07:32:44 +00:00
}
2014-03-12 22:17:23 +00:00
unmarshal_err := json.Unmarshal(resp_body, &ret)
if unmarshal_err != nil {
2020-08-26 16:51:20 +00:00
glog.Errorf("unmarshal %s: %v", uploadUrl, string(resp_body))
return nil, fmt.Errorf("unmarshal %v: %v", uploadUrl, unmarshal_err)
2012-09-26 10:27:10 +00:00
}
2013-01-17 08:56:56 +00:00
if ret.Error != "" {
2020-08-26 16:51:20 +00:00
return nil, fmt.Errorf("unmarshalled error %v: %v", uploadUrl, ret.Error)
2012-09-26 21:28:46 +00:00
}
2018-09-23 05:12:21 +00:00
ret.ETag = etag
ret.ContentMd5 = resp.Header.Get("Content-MD5")
2012-09-26 10:27:10 +00:00
return &ret, nil
2012-09-21 00:58:29 +00:00
}
2018-09-23 05:12:21 +00:00
func getEtag(r *http.Response) (etag string) {
etag = r.Header.Get("ETag")
if strings.HasPrefix(etag, "\"") && strings.HasSuffix(etag, "\"") {
etag = etag[1 : len(etag)-1]
}
return
}