seaweedfs/weed/operation/upload_content.go

168 lines
4.6 KiB
Go
Raw Normal View History

2012-09-21 00:58:29 +00:00
package operation
import (
"bufio"
"compress/flate"
"compress/gzip"
"crypto/rand"
2012-09-26 10:27:10 +00:00
"encoding/json"
2013-01-17 08:56:56 +00:00
"errors"
"fmt"
2012-09-26 10:27:10 +00:00
"io"
"mime"
2012-09-26 10:27:10 +00:00
"mime/multipart"
"net/http"
"net/textproto"
"path/filepath"
"strings"
"github.com/valyala/fasthttp"
"github.com/chrislusf/seaweedfs/weed/glog"
"github.com/chrislusf/seaweedfs/weed/security"
2019-04-19 04:43:36 +00:00
"github.com/chrislusf/seaweedfs/weed/util"
2012-09-21 00:58:29 +00:00
)
type UploadResult struct {
2014-04-15 17:01:13 +00:00
Name string `json:"name,omitempty"`
Size uint32 `json:"size,omitempty"`
Error string `json:"error,omitempty"`
2019-01-02 20:57:54 +00:00
ETag string `json:"eTag,omitempty"`
2012-09-21 00:58:29 +00:00
}
2014-03-12 21:07:01 +00:00
var (
client *http.Client
)
func init() {
client = &http.Client{Transport: &http.Transport{
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 UploadWithLocalCompressionLevel(uploadUrl string, filename string, reader io.Reader, isGzipped bool, mtype string, pairMap map[string]string, jwt security.EncodedJwt, compressionLevel int) (*UploadResult, error) {
if compressionLevel < 1 {
compressionLevel = 1
}
if compressionLevel > 9 {
compressionLevel = 9
}
return doUpload(uploadUrl, filename, reader, isGzipped, mtype, pairMap, compressionLevel, jwt)
}
// Upload sends a POST request to a volume server to upload the content with fast compression
func Upload(uploadUrl string, filename string, reader io.Reader, isGzipped bool, mtype string, pairMap map[string]string, jwt security.EncodedJwt) (*UploadResult, error) {
return doUpload(uploadUrl, filename, reader, isGzipped, mtype, pairMap, flate.BestSpeed, jwt)
}
func doUpload(uploadUrl string, filename string, reader io.Reader, isGzipped bool, mtype string, pairMap map[string]string, compression int, jwt security.EncodedJwt) (*UploadResult, error) {
contentIsGzipped := isGzipped
shouldGzipNow := false
if !isGzipped {
2019-04-19 04:43:36 +00:00
if shouldBeZipped, iAmSure := util.IsGzippableFileType(filepath.Base(filename), mtype); iAmSure && shouldBeZipped {
shouldGzipNow = true
contentIsGzipped = true
}
}
return upload_content(uploadUrl, func(w io.Writer) (err error) {
if shouldGzipNow {
gzWriter, _ := gzip.NewWriterLevel(w, compression)
_, err = io.Copy(gzWriter, reader)
gzWriter.Close()
} else {
_, err = io.Copy(w, reader)
}
return
}, filename, contentIsGzipped, mtype, pairMap, jwt)
}
func randomBoundary() string {
var buf [30]byte
_, err := io.ReadFull(rand.Reader, buf[:])
if err != nil {
panic(err)
}
return fmt.Sprintf("%x", buf[:])
}
func upload_content(uploadUrl string, fillBufferFunction func(w io.Writer) error, filename string, isGzipped bool, mtype string, pairMap map[string]string, jwt security.EncodedJwt) (*UploadResult, error) {
2013-07-29 17:09:36 +00:00
if mtype == "" {
mtype = mime.TypeByExtension(strings.ToLower(filepath.Ext(filename)))
}
boundary := randomBoundary()
contentType := "multipart/form-data; boundary=" + boundary
2012-09-26 10:27:10 +00:00
var ret UploadResult
var etag string
var writeErr error
err := util.PostContent(uploadUrl, func(w *bufio.Writer) {
h := make(textproto.MIMEHeader)
h.Set("Content-Disposition", fmt.Sprintf(`form-data; name="file"; filename="%s"`, fileNameEscaper.Replace(filename)))
if mtype != "" {
h.Set("Content-Type", mtype)
}
if isGzipped {
h.Set("Content-Encoding", "gzip")
}
body_writer := multipart.NewWriter(w)
body_writer.SetBoundary(boundary)
file_writer, cp_err := body_writer.CreatePart(h)
if cp_err != nil {
glog.V(0).Infoln("error creating form file", cp_err.Error())
writeErr = cp_err
return
}
if err := fillBufferFunction(file_writer); err != nil {
glog.V(0).Infoln("error copying data", err)
writeErr = err
return
}
if err := body_writer.Close(); err != nil {
glog.V(0).Infoln("error closing body", err)
writeErr = err
return
}
w.Flush()
}, func(header *fasthttp.RequestHeader) {
header.Set("Content-Type", contentType)
for k, v := range pairMap {
header.Set(k, v)
}
if jwt != "" {
header.Set("Authorization", "BEARER "+string(jwt))
}
}, func(resp *fasthttp.Response) error {
etagBytes := resp.Header.Peek("ETag")
lenEtagBytes := len(etagBytes)
if lenEtagBytes > 2 && etagBytes[0] == '"' && etagBytes[lenEtagBytes-1] == '"' {
etag = string(etagBytes[1 : len(etagBytes)-1])
}
unmarshal_err := json.Unmarshal(resp.Body(), &ret)
if unmarshal_err != nil {
glog.V(0).Infoln("failing to read upload response", uploadUrl, string(resp.Body()))
return unmarshal_err
}
if ret.Error != "" {
return errors.New(ret.Error)
}
return nil
})
if writeErr != nil {
return nil, writeErr
2012-09-26 21:28:46 +00:00
}
2018-09-23 05:12:21 +00:00
ret.ETag = etag
if err != nil {
return nil, err
2018-09-23 05:12:21 +00:00
}
return &ret, nil
2018-09-23 05:12:21 +00:00
}