|
|
package weed_server
import ( "bytes" "crypto/md5" "encoding/base64" "encoding/json" "errors" "fmt" "io" "io/ioutil" "mime/multipart" "net/http" "net/textproto" "net/url" "strings"
"github.com/chrislusf/seaweedfs/weed/glog" "github.com/chrislusf/seaweedfs/weed/operation" "github.com/chrislusf/seaweedfs/weed/storage" "github.com/chrislusf/seaweedfs/weed/util" "github.com/syndtr/goleveldb/leveldb" "path" "strconv" )
type FilerPostResult struct { Name string `json:"name,omitempty"` Size uint32 `json:"size,omitempty"` Error string `json:"error,omitempty"` Fid string `json:"fid,omitempty"` Url string `json:"url,omitempty"` }
var quoteEscaper = strings.NewReplacer("\\", "\\\\", `"`, "\\\"")
func escapeQuotes(s string) string { return quoteEscaper.Replace(s) }
func createFormFile(writer *multipart.Writer, fieldname, filename, mime string) (io.Writer, error) { h := make(textproto.MIMEHeader) h.Set("Content-Disposition", fmt.Sprintf(`form-data; name="%s"; filename="%s"`, escapeQuotes(fieldname), escapeQuotes(filename))) if len(mime) == 0 { mime = "application/octet-stream" } h.Set("Content-Type", mime) return writer.CreatePart(h) }
func makeFormData(filename, mimeType string, content io.Reader) (formData io.Reader, contentType string, err error) { buf := new(bytes.Buffer) writer := multipart.NewWriter(buf) defer writer.Close()
part, err := createFormFile(writer, "file", filename, mimeType) if err != nil { glog.V(0).Infoln(err) return } _, err = io.Copy(part, content) if err != nil { glog.V(0).Infoln(err) return }
formData = buf contentType = writer.FormDataContentType()
return }
func (fs *FilerServer) queryFileInfoByPath(w http.ResponseWriter, r *http.Request, path string) (fileId, urlLocation string, err error) { if fileId, err = fs.filer.FindFile(path); err != nil && err != leveldb.ErrNotFound { glog.V(0).Infoln("failing to find path in filer store", path, err.Error()) writeJsonError(w, r, http.StatusInternalServerError, err) return } else if fileId != "" && err == nil { urlLocation, err = operation.LookupFileId(fs.getMasterNode(), fileId) if err != nil { glog.V(1).Infoln("operation LookupFileId %s failed, err is %s", fileId, err.Error()) w.WriteHeader(http.StatusNotFound) return } } return }
func (fs *FilerServer) assignNewFileInfo(w http.ResponseWriter, r *http.Request, replication, collection string) (fileId, urlLocation string, err error) { ar := &operation.VolumeAssignRequest{ Count: 1, Replication: replication, Collection: collection, Ttl: r.URL.Query().Get("ttl"), } assignResult, ae := operation.Assign(fs.getMasterNode(), ar) if ae != nil { glog.V(0).Infoln("failing to assign a file id", ae.Error()) writeJsonError(w, r, http.StatusInternalServerError, ae) err = ae return } fileId = assignResult.Fid urlLocation = "http://" + assignResult.Url + "/" + assignResult.Fid return }
func (fs *FilerServer) multipartUploadAnalyzer(w http.ResponseWriter, r *http.Request, replication, collection string) (fileId, urlLocation string, err error) { //Default handle way for http multipart
if r.Method == "PUT" { buf, _ := ioutil.ReadAll(r.Body) r.Body = ioutil.NopCloser(bytes.NewBuffer(buf)) fileName, _, _, _, _, _, _, pe := storage.ParseUpload(r) if pe != nil { glog.V(0).Infoln("failing to parse post body", pe.Error()) writeJsonError(w, r, http.StatusInternalServerError, pe) err = pe return } //reconstruct http request body for following new request to volume server
r.Body = ioutil.NopCloser(bytes.NewBuffer(buf))
path := r.URL.Path if strings.HasSuffix(path, "/") { if fileName != "" { path += fileName } } fileId, urlLocation, err = fs.queryFileInfoByPath(w, r, path) } else { fileId, urlLocation, err = fs.assignNewFileInfo(w, r, replication, collection) } return }
func multipartHttpBodyBuilder(w http.ResponseWriter, r *http.Request, fileName string) (err error) { body, contentType, te := makeFormData(fileName, r.Header.Get("Content-Type"), r.Body) if te != nil { glog.V(0).Infoln("S3 protocol to raw seaweed protocol failed", te.Error()) writeJsonError(w, r, http.StatusInternalServerError, te) err = te return }
if body != nil { switch v := body.(type) { case *bytes.Buffer: r.ContentLength = int64(v.Len()) case *bytes.Reader: r.ContentLength = int64(v.Len()) case *strings.Reader: r.ContentLength = int64(v.Len()) } }
r.Header.Set("Content-Type", contentType) rc, ok := body.(io.ReadCloser) if !ok && body != nil { rc = ioutil.NopCloser(body) } r.Body = rc return }
func checkContentMD5(w http.ResponseWriter, r *http.Request) (err error) { if contentMD5 := r.Header.Get("Content-MD5"); contentMD5 != "" { buf, _ := ioutil.ReadAll(r.Body) //checkMD5
sum := md5.Sum(buf) fileDataMD5 := base64.StdEncoding.EncodeToString(sum[0:len(sum)]) if strings.ToLower(fileDataMD5) != strings.ToLower(contentMD5) { glog.V(0).Infof("fileDataMD5 [%s] is not equal to Content-MD5 [%s]", fileDataMD5, contentMD5) err = fmt.Errorf("MD5 check failed") writeJsonError(w, r, http.StatusNotAcceptable, err) return } //reconstruct http request body for following new request to volume server
r.Body = ioutil.NopCloser(bytes.NewBuffer(buf)) } return }
func (fs *FilerServer) monolithicUploadAnalyzer(w http.ResponseWriter, r *http.Request, replication, collection string) (fileId, urlLocation string, err error) { /* Amazon S3 ref link:[http://docs.aws.amazon.com/AmazonS3/latest/API/Welcome.html]
There is a long way to provide a completely compatibility against all Amazon S3 API, I just made a simple data stream adapter between S3 PUT API and seaweedfs's volume storage Write API 1. The request url format should be http://$host:$port/$bucketName/$objectName
2. bucketName will be mapped to seaweedfs's collection name 3. You could customize and make your enhancement. */ lastPos := strings.LastIndex(r.URL.Path, "/") if lastPos == -1 || lastPos == 0 || lastPos == len(r.URL.Path)-1 { glog.V(0).Infoln("URL Path [%s] is invalid, could not retrieve file name", r.URL.Path) err = fmt.Errorf("URL Path is invalid") writeJsonError(w, r, http.StatusInternalServerError, err) return }
if err = checkContentMD5(w, r); err != nil { return }
fileName := r.URL.Path[lastPos+1:] if err = multipartHttpBodyBuilder(w, r, fileName); err != nil { return }
secondPos := strings.Index(r.URL.Path[1:], "/") + 1 collection = r.URL.Path[1:secondPos] path := r.URL.Path
if fileId, urlLocation, err = fs.queryFileInfoByPath(w, r, path); err == nil && fileId == "" { fileId, urlLocation, err = fs.assignNewFileInfo(w, r, replication, collection) } return }
func (fs *FilerServer) PostHandler(w http.ResponseWriter, r *http.Request) {
query := r.URL.Query() replication := query.Get("replication") if replication == "" { replication = fs.defaultReplication } collection := query.Get("collection") if collection == "" { collection = fs.collection }
if autoChunked := fs.autoChunk(w, r, replication, collection); autoChunked { return }
var fileId, urlLocation string var err error
if strings.HasPrefix(r.Header.Get("Content-Type"), "multipart/form-data; boundary=") { fileId, urlLocation, err = fs.multipartUploadAnalyzer(w, r, replication, collection) if err != nil { return } } else { fileId, urlLocation, err = fs.monolithicUploadAnalyzer(w, r, replication, collection) if err != nil { return } }
u, _ := url.Parse(urlLocation)
// This allows a client to generate a chunk manifest and submit it to the filer -- it is a little off
// because they need to provide FIDs instead of file paths...
cm, _ := strconv.ParseBool(query.Get("cm")) if cm { q := u.Query() q.Set("cm", "true") u.RawQuery = q.Encode() } glog.V(4).Infoln("post to", u)
request := &http.Request{ Method: r.Method, URL: u, Proto: r.Proto, ProtoMajor: r.ProtoMajor, ProtoMinor: r.ProtoMinor, Header: r.Header, Body: r.Body, Host: r.Host, ContentLength: r.ContentLength, } resp, do_err := util.Do(request) if do_err != nil { glog.V(0).Infoln("failing to connect to volume server", r.RequestURI, do_err.Error()) writeJsonError(w, r, http.StatusInternalServerError, do_err) return } defer resp.Body.Close() resp_body, ra_err := ioutil.ReadAll(resp.Body) if ra_err != nil { glog.V(0).Infoln("failing to upload to volume server", r.RequestURI, ra_err.Error()) writeJsonError(w, r, http.StatusInternalServerError, ra_err) return } glog.V(4).Infoln("post result", string(resp_body)) var ret operation.UploadResult unmarshal_err := json.Unmarshal(resp_body, &ret) if unmarshal_err != nil { glog.V(0).Infoln("failing to read upload resonse", r.RequestURI, string(resp_body)) writeJsonError(w, r, http.StatusInternalServerError, unmarshal_err) return } if ret.Error != "" { glog.V(0).Infoln("failing to post to volume server", r.RequestURI, ret.Error) writeJsonError(w, r, http.StatusInternalServerError, errors.New(ret.Error)) return } path := r.URL.Path if strings.HasSuffix(path, "/") { if ret.Name != "" { path += ret.Name } else { operation.DeleteFile(fs.getMasterNode(), fileId, fs.jwt(fileId)) //clean up
glog.V(0).Infoln("Can not to write to folder", path, "without a file name!") writeJsonError(w, r, http.StatusInternalServerError, errors.New("Can not to write to folder "+path+" without a file name")) return } }
// also delete the old fid unless PUT operation
if r.Method != "PUT" { if oldFid, err := fs.filer.FindFile(path); err == nil { operation.DeleteFile(fs.getMasterNode(), oldFid, fs.jwt(oldFid)) } }
glog.V(4).Infoln("saving", path, "=>", fileId) if db_err := fs.filer.CreateFile(path, fileId); db_err != nil { operation.DeleteFile(fs.getMasterNode(), fileId, fs.jwt(fileId)) //clean up
glog.V(0).Infof("failing to write %s to filer server : %v", path, db_err) writeJsonError(w, r, http.StatusInternalServerError, db_err) return }
reply := FilerPostResult{ Name: ret.Name, Size: ret.Size, Error: ret.Error, Fid: fileId, Url: urlLocation, } writeJsonQuiet(w, r, http.StatusCreated, reply) }
func (fs *FilerServer) autoChunk(w http.ResponseWriter, r *http.Request, replication string, collection string) bool { if r.Method != "POST" { glog.V(4).Infoln("AutoChunking not supported for method", r.Method) return false }
// autoChunking can be set at the command-line level or as a query param. Query param overrides command-line
query := r.URL.Query()
parsedMaxMB, _ := strconv.ParseInt(query.Get("maxMB"), 10, 32) maxMB := int32(parsedMaxMB) if maxMB <= 0 && fs.maxMB > 0 { maxMB = int32(fs.maxMB) } if maxMB <= 0 { glog.V(4).Infoln("AutoChunking not enabled") return false } glog.V(4).Infoln("AutoChunking level set to", maxMB, "(MB)")
chunkSize := 1024 * 1024 * maxMB
contentLength := int64(0) if contentLengthHeader := r.Header["Content-Length"]; len(contentLengthHeader) == 1 { contentLength, _ = strconv.ParseInt(contentLengthHeader[0], 10, 64) if contentLength <= int64(chunkSize) { glog.V(4).Infoln("Content-Length of", contentLength, "is less than the chunk size of", chunkSize, "so autoChunking will be skipped.") return false } }
if contentLength <= 0 { glog.V(4).Infoln("Content-Length value is missing or unexpected so autoChunking will be skipped.") return false }
reply, err := fs.doAutoChunk(w, r, contentLength, chunkSize, replication, collection) if err != nil { writeJsonError(w, r, http.StatusInternalServerError, err) } else if reply != nil { writeJsonQuiet(w, r, http.StatusCreated, reply) } return true }
func (fs *FilerServer) doAutoChunk(w http.ResponseWriter, r *http.Request, contentLength int64, chunkSize int32, replication string, collection string) (filerResult *FilerPostResult, replyerr error) {
multipartReader, multipartReaderErr := r.MultipartReader() if multipartReaderErr != nil { return nil, multipartReaderErr }
part1, part1Err := multipartReader.NextPart() if part1Err != nil { return nil, part1Err }
fileName := part1.FileName() if fileName != "" { fileName = path.Base(fileName) }
chunks := (int64(contentLength) / int64(chunkSize)) + 1 cm := operation.ChunkManifest{ Name: fileName, Size: 0, // don't know yet
Mime: "application/octet-stream", Chunks: make([]*operation.ChunkInfo, 0, chunks), }
totalBytesRead := int64(0) tmpBufferSize := int32(1024 * 1024) tmpBuffer := bytes.NewBuffer(make([]byte, 0, tmpBufferSize)) chunkBuf := make([]byte, chunkSize+tmpBufferSize, chunkSize+tmpBufferSize) // chunk size plus a little overflow
chunkBufOffset := int32(0) chunkOffset := int64(0) writtenChunks := 0
filerResult = &FilerPostResult{ Name: fileName, }
for totalBytesRead < contentLength { tmpBuffer.Reset() bytesRead, readErr := io.CopyN(tmpBuffer, part1, int64(tmpBufferSize)) readFully := readErr != nil && readErr == io.EOF tmpBuf := tmpBuffer.Bytes() bytesToCopy := tmpBuf[0:int(bytesRead)]
copy(chunkBuf[chunkBufOffset:chunkBufOffset+int32(bytesRead)], bytesToCopy) chunkBufOffset = chunkBufOffset + int32(bytesRead)
if chunkBufOffset >= chunkSize || readFully || (chunkBufOffset > 0 && bytesRead == 0) { writtenChunks = writtenChunks + 1 fileId, urlLocation, assignErr := fs.assignNewFileInfo(w, r, replication, collection) if assignErr != nil { return nil, assignErr }
// upload the chunk to the volume server
chunkName := fileName + "_chunk_" + strconv.FormatInt(int64(cm.Chunks.Len()+1), 10) uploadErr := fs.doUpload(urlLocation, w, r, chunkBuf[0:chunkBufOffset], chunkName, "application/octet-stream", fileId) if uploadErr != nil { return nil, uploadErr }
// Save to chunk manifest structure
cm.Chunks = append(cm.Chunks, &operation.ChunkInfo{ Offset: chunkOffset, Size: int64(chunkBufOffset), Fid: fileId, }, )
// reset variables for the next chunk
chunkBufOffset = 0 chunkOffset = totalBytesRead + int64(bytesRead) }
totalBytesRead = totalBytesRead + int64(bytesRead)
if bytesRead == 0 || readFully { break }
if readErr != nil { return nil, readErr } }
cm.Size = totalBytesRead manifestBuf, marshalErr := cm.Marshal() if marshalErr != nil { return nil, marshalErr }
manifestStr := string(manifestBuf) glog.V(4).Infoln("Generated chunk manifest: ", manifestStr)
manifestFileId, manifestUrlLocation, manifestAssignmentErr := fs.assignNewFileInfo(w, r, replication, collection) if manifestAssignmentErr != nil { return nil, manifestAssignmentErr } glog.V(4).Infoln("Manifest uploaded to:", manifestUrlLocation, "Fid:", manifestFileId) filerResult.Fid = manifestFileId
u, _ := url.Parse(manifestUrlLocation) q := u.Query() q.Set("cm", "true") u.RawQuery = q.Encode()
manifestUploadErr := fs.doUpload(u.String(), w, r, manifestBuf, fileName+"_manifest", "application/json", manifestFileId) if manifestUploadErr != nil { return nil, manifestUploadErr }
path := r.URL.Path // also delete the old fid unless PUT operation
if r.Method != "PUT" { if oldFid, err := fs.filer.FindFile(path); err == nil { operation.DeleteFile(fs.getMasterNode(), oldFid, fs.jwt(oldFid)) } }
glog.V(4).Infoln("saving", path, "=>", manifestFileId) if db_err := fs.filer.CreateFile(path, manifestFileId); db_err != nil { replyerr = db_err filerResult.Error = db_err.Error() operation.DeleteFile(fs.getMasterNode(), manifestFileId, fs.jwt(manifestFileId)) //clean up
glog.V(0).Infof("failing to write %s to filer server : %v", path, db_err) return }
return }
func (fs *FilerServer) doUpload(urlLocation string, w http.ResponseWriter, r *http.Request, chunkBuf []byte, fileName string, contentType string, fileId string) (err error) { err = nil
ioReader := ioutil.NopCloser(bytes.NewBuffer(chunkBuf)) uploadResult, uploadError := operation.Upload(urlLocation, fileName, ioReader, false, contentType, fs.jwt(fileId)) if uploadResult != nil { glog.V(0).Infoln("Chunk upload result. Name:", uploadResult.Name, "Fid:", fileId, "Size:", uploadResult.Size) } if uploadError != nil { err = uploadError } return }
// curl -X DELETE http://localhost:8888/path/to
// curl -X DELETE http://localhost:8888/path/to?recursive=true
func (fs *FilerServer) DeleteHandler(w http.ResponseWriter, r *http.Request) { var err error var fid string if strings.HasSuffix(r.URL.Path, "/") { isRecursive := r.FormValue("recursive") == "true" err = fs.filer.DeleteDirectory(r.URL.Path, isRecursive) } else { fid, err = fs.filer.DeleteFile(r.URL.Path) if err == nil && fid != "" { err = operation.DeleteFile(fs.getMasterNode(), fid, fs.jwt(fid)) } } if err == nil { writeJsonQuiet(w, r, http.StatusAccepted, map[string]string{"error": ""}) } else { glog.V(4).Infoln("deleting", r.URL.Path, ":", err.Error()) writeJsonError(w, r, http.StatusInternalServerError, err) } }
|