2013-12-02 09:37:36 +00:00
|
|
|
package weed_server
|
|
|
|
|
|
|
|
import (
|
|
|
|
"bytes"
|
|
|
|
"encoding/json"
|
2015-01-08 08:19:32 +00:00
|
|
|
"errors"
|
2013-12-02 09:37:36 +00:00
|
|
|
"fmt"
|
|
|
|
"net/http"
|
|
|
|
"path/filepath"
|
|
|
|
"strconv"
|
|
|
|
"strings"
|
2015-03-22 19:50:04 +00:00
|
|
|
"time"
|
2014-10-26 18:34:55 +00:00
|
|
|
|
2019-12-06 14:57:32 +00:00
|
|
|
"google.golang.org/grpc"
|
|
|
|
|
2016-06-03 01:09:14 +00:00
|
|
|
"github.com/chrislusf/seaweedfs/weed/glog"
|
|
|
|
"github.com/chrislusf/seaweedfs/weed/operation"
|
|
|
|
"github.com/chrislusf/seaweedfs/weed/stats"
|
2019-12-02 23:08:28 +00:00
|
|
|
"github.com/chrislusf/seaweedfs/weed/storage/needle"
|
2016-06-03 01:09:14 +00:00
|
|
|
"github.com/chrislusf/seaweedfs/weed/util"
|
2018-10-07 17:54:05 +00:00
|
|
|
|
2018-10-12 07:05:15 +00:00
|
|
|
"github.com/gorilla/mux"
|
2018-10-14 07:30:20 +00:00
|
|
|
statik "github.com/rakyll/statik/fs"
|
2019-12-06 14:57:32 +00:00
|
|
|
|
|
|
|
_ "github.com/chrislusf/seaweedfs/weed/statik"
|
2013-12-02 09:37:36 +00:00
|
|
|
)
|
|
|
|
|
2014-03-25 20:46:59 +00:00
|
|
|
var serverStats *stats.ServerStats
|
2015-03-22 19:50:04 +00:00
|
|
|
var startTime = time.Now()
|
2018-10-07 17:54:05 +00:00
|
|
|
var statikFS http.FileSystem
|
2014-03-25 20:46:59 +00:00
|
|
|
|
|
|
|
func init() {
|
|
|
|
serverStats = stats.NewServerStats()
|
|
|
|
go serverStats.Start()
|
2018-10-07 17:54:05 +00:00
|
|
|
statikFS, _ = statik.New()
|
2014-03-25 20:46:59 +00:00
|
|
|
}
|
|
|
|
|
2015-01-08 08:19:32 +00:00
|
|
|
func writeJson(w http.ResponseWriter, r *http.Request, httpStatus int, obj interface{}) (err error) {
|
2013-12-02 09:37:36 +00:00
|
|
|
var bytes []byte
|
|
|
|
if r.FormValue("pretty") != "" {
|
|
|
|
bytes, err = json.MarshalIndent(obj, "", " ")
|
|
|
|
} else {
|
|
|
|
bytes, err = json.Marshal(obj)
|
|
|
|
}
|
|
|
|
if err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
callback := r.FormValue("callback")
|
|
|
|
if callback == "" {
|
2014-06-14 01:16:03 +00:00
|
|
|
w.Header().Set("Content-Type", "application/json")
|
2015-01-08 08:19:32 +00:00
|
|
|
w.WriteHeader(httpStatus)
|
2019-08-09 21:38:54 +00:00
|
|
|
if httpStatus == http.StatusNotModified {
|
|
|
|
return
|
|
|
|
}
|
2013-12-02 09:37:36 +00:00
|
|
|
_, err = w.Write(bytes)
|
|
|
|
} else {
|
2014-06-14 01:16:03 +00:00
|
|
|
w.Header().Set("Content-Type", "application/javascript")
|
2015-01-08 08:19:32 +00:00
|
|
|
w.WriteHeader(httpStatus)
|
2019-08-09 21:38:54 +00:00
|
|
|
if httpStatus == http.StatusNotModified {
|
|
|
|
return
|
|
|
|
}
|
2013-12-02 09:37:36 +00:00
|
|
|
if _, err = w.Write([]uint8(callback)); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
if _, err = w.Write([]uint8("(")); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
fmt.Fprint(w, string(bytes))
|
|
|
|
if _, err = w.Write([]uint8(")")); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
}
|
2015-01-08 08:19:32 +00:00
|
|
|
|
2013-12-02 09:37:36 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// wrapper for writeJson - just logs errors
|
2015-01-08 08:19:32 +00:00
|
|
|
func writeJsonQuiet(w http.ResponseWriter, r *http.Request, httpStatus int, obj interface{}) {
|
|
|
|
if err := writeJson(w, r, httpStatus, obj); err != nil {
|
2020-01-22 06:45:50 +00:00
|
|
|
glog.V(0).Infof("error writing JSON status %d: %v", httpStatus, err)
|
|
|
|
glog.V(1).Infof("JSON content: %+v", obj)
|
2013-12-02 09:37:36 +00:00
|
|
|
}
|
|
|
|
}
|
2015-01-08 08:19:32 +00:00
|
|
|
func writeJsonError(w http.ResponseWriter, r *http.Request, httpStatus int, err error) {
|
2013-12-02 09:37:36 +00:00
|
|
|
m := make(map[string]interface{})
|
|
|
|
m["error"] = err.Error()
|
2015-01-08 08:19:32 +00:00
|
|
|
writeJsonQuiet(w, r, httpStatus, m)
|
2013-12-02 09:37:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
func debug(params ...interface{}) {
|
2018-06-12 06:51:36 +00:00
|
|
|
glog.V(4).Infoln(params...)
|
2013-12-02 09:37:36 +00:00
|
|
|
}
|
|
|
|
|
2019-02-18 20:11:52 +00:00
|
|
|
func submitForClientHandler(w http.ResponseWriter, r *http.Request, masterUrl string, grpcDialOption grpc.DialOption) {
|
2013-12-02 09:37:36 +00:00
|
|
|
m := make(map[string]interface{})
|
|
|
|
if r.Method != "POST" {
|
2015-01-08 08:19:32 +00:00
|
|
|
writeJsonError(w, r, http.StatusMethodNotAllowed, errors.New("Only submit via POST!"))
|
2013-12-02 09:37:36 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
debug("parsing upload file...")
|
2020-01-03 08:37:24 +00:00
|
|
|
fname, data, mimeType, pairMap, isGzipped, originalDataSize, lastModified, _, _, pe := needle.ParseUpload(r, 256*1024*1024)
|
2013-12-02 09:37:36 +00:00
|
|
|
if pe != nil {
|
2015-01-08 08:19:32 +00:00
|
|
|
writeJsonError(w, r, http.StatusBadRequest, pe)
|
2013-12-02 09:37:36 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
debug("assigning file id for", fname)
|
2015-01-06 11:31:26 +00:00
|
|
|
r.ParseForm()
|
2018-11-22 21:45:29 +00:00
|
|
|
count := uint64(1)
|
|
|
|
if r.FormValue("count") != "" {
|
|
|
|
count, pe = strconv.ParseUint(r.FormValue("count"), 10, 32)
|
|
|
|
if pe != nil {
|
|
|
|
writeJsonError(w, r, http.StatusBadRequest, pe)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
}
|
2016-06-26 02:50:18 +00:00
|
|
|
ar := &operation.VolumeAssignRequest{
|
2018-11-22 21:45:29 +00:00
|
|
|
Count: count,
|
2019-12-05 23:51:24 +00:00
|
|
|
DataCenter: r.FormValue("dataCenter"),
|
2016-06-26 02:50:18 +00:00
|
|
|
Replication: r.FormValue("replication"),
|
|
|
|
Collection: r.FormValue("collection"),
|
|
|
|
Ttl: r.FormValue("ttl"),
|
|
|
|
}
|
2019-02-18 20:11:52 +00:00
|
|
|
assignResult, ae := operation.Assign(masterUrl, grpcDialOption, ar)
|
2013-12-02 09:37:36 +00:00
|
|
|
if ae != nil {
|
2015-01-08 08:19:32 +00:00
|
|
|
writeJsonError(w, r, http.StatusInternalServerError, ae)
|
2013-12-02 09:37:36 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2015-02-02 18:16:50 +00:00
|
|
|
url := "http://" + assignResult.Url + "/" + assignResult.Fid
|
2013-12-02 09:37:36 +00:00
|
|
|
if lastModified != 0 {
|
|
|
|
url = url + "?ts=" + strconv.FormatUint(lastModified, 10)
|
|
|
|
}
|
|
|
|
|
|
|
|
debug("upload file to store", url)
|
2020-03-06 08:49:47 +00:00
|
|
|
uploadResult, err := operation.Upload(url, fname, false, bytes.NewReader(data), isGzipped, mimeType, pairMap, assignResult.Auth)
|
2013-12-02 09:37:36 +00:00
|
|
|
if err != nil {
|
2015-01-08 08:19:32 +00:00
|
|
|
writeJsonError(w, r, http.StatusInternalServerError, err)
|
2013-12-02 09:37:36 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
m["fileName"] = fname
|
|
|
|
m["fid"] = assignResult.Fid
|
|
|
|
m["fileUrl"] = assignResult.PublicUrl + "/" + assignResult.Fid
|
2018-12-22 21:11:07 +00:00
|
|
|
m["size"] = originalDataSize
|
2018-09-23 05:12:21 +00:00
|
|
|
m["eTag"] = uploadResult.ETag
|
2015-01-08 08:19:32 +00:00
|
|
|
writeJsonQuiet(w, r, http.StatusCreated, m)
|
2013-12-02 09:37:36 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
func parseURLPath(path string) (vid, fid, filename, ext string, isVolumeIdOnly bool) {
|
|
|
|
switch strings.Count(path, "/") {
|
|
|
|
case 3:
|
|
|
|
parts := strings.Split(path, "/")
|
|
|
|
vid, fid, filename = parts[1], parts[2], parts[3]
|
|
|
|
ext = filepath.Ext(filename)
|
|
|
|
case 2:
|
|
|
|
parts := strings.Split(path, "/")
|
|
|
|
vid, fid = parts[1], parts[2]
|
|
|
|
dotIndex := strings.LastIndex(fid, ".")
|
|
|
|
if dotIndex > 0 {
|
|
|
|
ext = fid[dotIndex:]
|
|
|
|
fid = fid[0:dotIndex]
|
|
|
|
}
|
|
|
|
default:
|
|
|
|
sepIndex := strings.LastIndex(path, "/")
|
|
|
|
commaIndex := strings.LastIndex(path[sepIndex:], ",")
|
|
|
|
if commaIndex <= 0 {
|
|
|
|
vid, isVolumeIdOnly = path[sepIndex+1:], true
|
|
|
|
return
|
|
|
|
}
|
|
|
|
dotIndex := strings.LastIndex(path[sepIndex:], ".")
|
|
|
|
vid = path[sepIndex+1 : commaIndex]
|
|
|
|
fid = path[commaIndex+1:]
|
|
|
|
ext = ""
|
|
|
|
if dotIndex > 0 {
|
|
|
|
fid = path[commaIndex+1 : dotIndex]
|
|
|
|
ext = path[dotIndex:]
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return
|
|
|
|
}
|
2014-04-14 06:41:34 +00:00
|
|
|
|
2018-05-07 07:37:33 +00:00
|
|
|
func statsHealthHandler(w http.ResponseWriter, r *http.Request) {
|
|
|
|
m := make(map[string]interface{})
|
|
|
|
m["Version"] = util.VERSION
|
|
|
|
writeJsonQuiet(w, r, http.StatusOK, m)
|
|
|
|
}
|
2014-03-25 20:46:59 +00:00
|
|
|
func statsCounterHandler(w http.ResponseWriter, r *http.Request) {
|
|
|
|
m := make(map[string]interface{})
|
|
|
|
m["Version"] = util.VERSION
|
2014-03-26 20:22:27 +00:00
|
|
|
m["Counters"] = serverStats
|
2015-01-08 08:19:32 +00:00
|
|
|
writeJsonQuiet(w, r, http.StatusOK, m)
|
2014-03-25 20:46:59 +00:00
|
|
|
}
|
2014-03-26 20:22:27 +00:00
|
|
|
|
2014-03-25 20:46:59 +00:00
|
|
|
func statsMemoryHandler(w http.ResponseWriter, r *http.Request) {
|
|
|
|
m := make(map[string]interface{})
|
|
|
|
m["Version"] = util.VERSION
|
2014-03-26 20:22:27 +00:00
|
|
|
m["Memory"] = stats.MemStat()
|
2015-01-08 08:19:32 +00:00
|
|
|
writeJsonQuiet(w, r, http.StatusOK, m)
|
2014-03-25 20:46:59 +00:00
|
|
|
}
|
2018-05-28 09:35:58 +00:00
|
|
|
|
2018-10-07 17:54:05 +00:00
|
|
|
func handleStaticResources(defaultMux *http.ServeMux) {
|
|
|
|
defaultMux.Handle("/favicon.ico", http.FileServer(statikFS))
|
|
|
|
defaultMux.Handle("/seaweedfsstatic/", http.StripPrefix("/seaweedfsstatic", http.FileServer(statikFS)))
|
2018-05-28 09:35:58 +00:00
|
|
|
}
|
2018-10-12 07:05:15 +00:00
|
|
|
|
|
|
|
func handleStaticResources2(r *mux.Router) {
|
|
|
|
r.Handle("/favicon.ico", http.FileServer(statikFS))
|
|
|
|
r.PathPrefix("/seaweedfsstatic/").Handler(http.StripPrefix("/seaweedfsstatic", http.FileServer(statikFS)))
|
|
|
|
}
|