seaweedfs/weed/server/volume_server_handlers_write.go

182 lines
4.9 KiB
Go
Raw Normal View History

package weed_server
import (
"bytes"
"errors"
2015-12-15 06:38:58 +00:00
"fmt"
"net/http"
2018-09-12 07:46:12 +00:00
"strconv"
"strings"
2018-09-12 08:00:57 +00:00
"time"
"github.com/chrislusf/seaweedfs/weed/glog"
"github.com/chrislusf/seaweedfs/weed/operation"
2019-06-15 19:21:44 +00:00
"github.com/chrislusf/seaweedfs/weed/stats"
2019-04-19 04:43:36 +00:00
"github.com/chrislusf/seaweedfs/weed/storage/needle"
"github.com/chrislusf/seaweedfs/weed/topology"
)
func (vs *VolumeServer) PostHandler(w http.ResponseWriter, r *http.Request) {
2019-06-14 07:54:56 +00:00
2019-06-15 19:21:44 +00:00
stats.VolumeServerRequestCounter.WithLabelValues("post").Inc()
2019-06-14 07:54:56 +00:00
start := time.Now()
2019-06-16 04:46:55 +00:00
defer func() {
stats.VolumeServerRequestHistogram.WithLabelValues("post").Observe(time.Since(start).Seconds())
}()
2019-06-14 07:54:56 +00:00
if e := r.ParseForm(); e != nil {
glog.V(0).Infoln("form parse error:", e)
writeJsonError(w, r, http.StatusBadRequest, e)
return
}
vid, fid, _, _, _ := parseURLPath(r.URL.Path)
2019-04-19 04:43:36 +00:00
volumeId, ve := needle.NewVolumeId(vid)
if ve != nil {
glog.V(0).Infoln("NewVolumeId error:", ve)
writeJsonError(w, r, http.StatusBadRequest, ve)
return
}
2019-06-06 07:29:02 +00:00
if !vs.maybeCheckJwtAuthorization(r, vid, fid, true) {
writeJsonError(w, r, http.StatusUnauthorized, errors.New("wrong jwt"))
return
}
bytesBuffer := bufPool.Get().(*bytes.Buffer)
defer bufPool.Put(bytesBuffer)
reqNeedle, originalSize, contentMd5, ne := needle.CreateNeedleFromRequest(r, vs.FixJpgOrientation, vs.fileSizeLimitBytes, bytesBuffer)
if ne != nil {
writeJsonError(w, r, http.StatusBadRequest, ne)
return
}
ret := operation.UploadResult{}
isUnchanged, writeError := topology.ReplicatedWrite(vs.GetMaster, vs.store, volumeId, reqNeedle, r)
2019-12-24 09:56:50 +00:00
// http 204 status code does not allow body
2019-12-24 09:56:50 +00:00
if writeError == nil && isUnchanged {
setEtag(w, reqNeedle.Etag())
w.WriteHeader(http.StatusNoContent)
2019-12-24 09:56:50 +00:00
return
}
2019-12-24 09:56:50 +00:00
httpStatus := http.StatusCreated
if writeError != nil {
httpStatus = http.StatusInternalServerError
ret.Error = writeError.Error()
}
if reqNeedle.HasName() {
ret.Name = string(reqNeedle.Name)
}
ret.Size = uint32(originalSize)
2021-04-16 18:22:31 +00:00
ret.ETag = reqNeedle.Etag()
ret.Mime = string(reqNeedle.Mime)
2019-01-02 20:57:54 +00:00
setEtag(w, ret.ETag)
w.Header().Set("Content-MD5", contentMd5)
writeJsonQuiet(w, r, httpStatus, ret)
}
func (vs *VolumeServer) DeleteHandler(w http.ResponseWriter, r *http.Request) {
2019-06-14 07:54:56 +00:00
2019-06-15 19:21:44 +00:00
stats.VolumeServerRequestCounter.WithLabelValues("delete").Inc()
2019-06-14 07:54:56 +00:00
start := time.Now()
2019-06-16 04:46:55 +00:00
defer func() {
stats.VolumeServerRequestHistogram.WithLabelValues("delete").Observe(time.Since(start).Seconds())
}()
2019-06-14 07:54:56 +00:00
2019-04-19 04:43:36 +00:00
n := new(needle.Needle)
vid, fid, _, _, _ := parseURLPath(r.URL.Path)
2019-04-19 04:43:36 +00:00
volumeId, _ := needle.NewVolumeId(vid)
n.ParsePath(fid)
2019-06-06 07:29:02 +00:00
if !vs.maybeCheckJwtAuthorization(r, vid, fid, true) {
writeJsonError(w, r, http.StatusUnauthorized, errors.New("wrong jwt"))
return
}
2018-10-15 07:39:56 +00:00
// glog.V(2).Infof("volume %s deleting %s", vid, n)
cookie := n.Cookie
ecVolume, hasEcVolume := vs.store.FindEcVolume(volumeId)
if hasEcVolume {
2020-02-26 06:23:59 +00:00
count, err := vs.store.DeleteEcShardNeedle(ecVolume, n, cookie)
writeDeleteResult(err, count, w, r)
return
}
_, ok := vs.store.ReadVolumeNeedle(volumeId, n, nil)
if ok != nil {
m := make(map[string]uint32)
m["size"] = 0
writeJsonQuiet(w, r, http.StatusNotFound, m)
return
}
if n.Cookie != cookie {
glog.V(0).Infoln("delete", r.URL.Path, "with unmaching cookie from ", r.RemoteAddr, "agent", r.UserAgent())
writeJsonError(w, r, http.StatusBadRequest, errors.New("File Random Cookie does not match."))
return
}
2015-12-02 13:45:26 +00:00
count := int64(n.Size)
if n.IsChunkedManifest() {
2020-06-20 05:45:27 +00:00
chunkManifest, e := operation.LoadChunkManifest(n.Data, n.IsCompressed())
if e != nil {
2015-12-15 06:38:58 +00:00
writeJsonError(w, r, http.StatusInternalServerError, fmt.Errorf("Load chunks manifest error: %v", e))
return
}
2015-12-03 13:35:33 +00:00
// make sure all chunks had deleted before delete manifest
if e := chunkManifest.DeleteChunks(vs.GetMaster, false, vs.grpcDialOption); e != nil {
2015-12-15 06:38:58 +00:00
writeJsonError(w, r, http.StatusInternalServerError, fmt.Errorf("Delete chunks error: %v", e))
return
}
count = chunkManifest.Size
}
n.LastModified = uint64(time.Now().Unix())
if len(r.FormValue("ts")) > 0 {
modifiedTime, err := strconv.ParseInt(r.FormValue("ts"), 10, 64)
if err == nil {
n.LastModified = uint64(modifiedTime)
}
}
_, err := topology.ReplicatedDelete(vs.GetMaster, vs.store, volumeId, n, r)
writeDeleteResult(err, count, w, r)
}
func writeDeleteResult(err error, count int64, w http.ResponseWriter, r *http.Request) {
2016-04-28 16:29:21 +00:00
if err == nil {
2015-12-02 13:45:26 +00:00
m := make(map[string]int64)
m["size"] = count
writeJsonQuiet(w, r, http.StatusAccepted, m)
} else {
2016-04-28 16:29:21 +00:00
writeJsonError(w, r, http.StatusInternalServerError, fmt.Errorf("Deletion Failed: %v", err))
}
}
2018-09-09 23:25:43 +00:00
func setEtag(w http.ResponseWriter, etag string) {
if etag != "" {
2018-09-12 07:46:12 +00:00
if strings.HasPrefix(etag, "\"") {
w.Header().Set("ETag", etag)
} else {
w.Header().Set("ETag", "\""+etag+"\"")
}
2018-09-09 23:25:43 +00:00
}
}
2020-04-13 04:00:55 +00:00
func getEtag(resp *http.Response) (etag string) {
etag = resp.Header.Get("ETag")
2020-04-13 04:00:55 +00:00
if strings.HasPrefix(etag, "\"") && strings.HasSuffix(etag, "\"") {
return etag[1 : len(etag)-1]
}
return
}