Add the file downloader.

rest/alien_controller.go

@@ -3,12 +3,12 @@ package rest
 import (
 	"fmt"
 	"net/http"
-	"net/url"
 	"os"
 	"regexp"
 	"strconv"
-	"strings"
 	"time"
+	"strings"
+	"net/url"
 )
 
 type AlienController struct {
@@ -347,22 +347,21 @@ func (this *AlienController) Download(writer http.ResponseWriter, request *http.
 	this.PanicError(err)
 	defer diskFile.Close()
 
-	// 防止中文乱码
-	fileName := url.QueryEscape(matter.Name)
-	mimeType := GetMimeType(fileName)
-	writer.Header().Set("Content-Type", mimeType)
-
-	//如果是图片或者文本或者视频就直接打开。其余的一律以下载形式返回。
-	if strings.Index(mimeType, "image") != 0 && strings.Index(mimeType, "text") != 0 && strings.Index(mimeType, "video") != 0 {
-		writer.Header().Set("content-disposition", "attachment; filename=\""+fileName+"\"")
-	}
-
 	//对图片做缩放处理。
 	imageProcess := request.FormValue("imageProcess")
 	if imageProcess == "resize" {
 		this.matterService.ResizeImage(writer, request, matter, diskFile)
 	} else {
 
+		//如果是图片或者文本或者视频就直接打开。其余的一律以下载形式返回。
+		fileName := url.QueryEscape(matter.Name)
+		mimeType := GetMimeType(fileName)
+		if strings.Index(mimeType, "image") != 0 && strings.Index(mimeType, "text") != 0 && strings.Index(mimeType, "video") != 0 {
+			writer.Header().Set("content-disposition", "attachment; filename=\""+fileName+"\"")
+		}
+
+		this.matterService.DownloadFile(writer, request, matter, diskFile)
+
 		//显示文件大小。
 		//fileInfo, err := diskFile.Stat()
 		//if err != nil {

rest/bean.go

@@ -1,8 +1,11 @@
 package rest
 
+import "net/http"
+
 type IBean interface {
 	Init(context *Context)
 	PanicError(err error);
+	PanicWebError(msg string, code int);
 }
 
 type Bean struct {
@@ -16,6 +19,11 @@ func (this *Bean) Init(context *Context) {
 //处理错误的统一方法
 func (this *Bean) PanicError(err error) {
 	if err != nil {
-		panic(err)
+		panic(&WebError{Msg: err.Error(), Code: http.StatusInternalServerError})
 	}
 }
+
+//处理错误的统一方法
+func (this *Bean) PanicWebError(msg string, httpStatusCode int) {
+	panic(&WebError{Msg: msg, Code: httpStatusCode})
+}

rest/matter_service.go

@@ -9,6 +9,13 @@ import (
 	"net/http"
 	"github.com/disintegration/imaging"
 	"strconv"
+	"mime"
+	"path/filepath"
+	"net/url"
+	"errors"
+	"time"
+	"fmt"
+	"net/textproto"
 )
 
 //@Service
@@ -159,9 +166,14 @@ func (this *MatterService) Upload(file multipart.File, user *User, puuid string,
 	return matter
 }
 
-//处理图片下载功能。
+//图片预处理功能。
 func (this *MatterService) ResizeImage(writer http.ResponseWriter, request *http.Request, matter *Matter, diskFile *os.File) {
 
+	// 防止中文乱码
+	fileName := url.QueryEscape(matter.Name)
+	mimeType := GetMimeType(fileName)
+	writer.Header().Set("Content-Type", mimeType)
+
 	//当前的文件是否是图片，只有图片才能处理。
 	extension := GetExtension(matter.Name)
 	formats := map[string]imaging.Format{
@@ -252,3 +264,318 @@ func (this *MatterService) ResizeImage(writer http.ResponseWriter, request *http
 	}
 
 }
+
+//检查Last-Modified头。返回true: 请求已经完成了。（言下之意，文件没有修改过） 返回false：文件修改过。
+func checkLastModified(w http.ResponseWriter, r *http.Request, modifyTime time.Time) bool {
+	if modifyTime.IsZero() {
+		return false
+	}
+
+	// The Date-Modified header truncates sub-second precision, so
+	// use mtime < t+1s instead of mtime <= t to check for unmodified.
+	if t, err := time.Parse(http.TimeFormat, r.Header.Get("If-Modified-Since")); err == nil && modifyTime.Before(t.Add(1*time.Second)) {
+		h := w.Header()
+		delete(h, "Content-Type")
+		delete(h, "Content-Length")
+		w.WriteHeader(http.StatusNotModified)
+		return true
+	}
+	w.Header().Set("Last-Modified", modifyTime.UTC().Format(http.TimeFormat))
+	return false
+}
+
+// 处理ETag标签
+// checkETag implements If-None-Match and If-Range checks.
+//
+// The ETag or modtime must have been previously set in the
+// ResponseWriter's headers.  The modtime is only compared at second
+// granularity and may be the zero value to mean unknown.
+//
+// The return value is the effective request "Range" header to use and
+// whether this request is now considered done.
+func checkETag(w http.ResponseWriter, r *http.Request, modtime time.Time) (rangeReq string, done bool) {
+	etag := w.Header().Get("Etag")
+	rangeReq = r.Header.Get("Range")
+
+	// Invalidate the range request if the entity doesn't match the one
+	// the client was expecting.
+	// "If-Range: version" means "ignore the Range: header unless version matches the
+	// current file."
+	// We only support ETag versions.
+	// The caller must have set the ETag on the response already.
+	if ir := r.Header.Get("If-Range"); ir != "" && ir != etag {
+		// The If-Range value is typically the ETag value, but it may also be
+		// the modtime date. See golang.org/issue/8367.
+		timeMatches := false
+		if !modtime.IsZero() {
+			if t, err := http.ParseTime(ir); err == nil && t.Unix() == modtime.Unix() {
+				timeMatches = true
+			}
+		}
+		if !timeMatches {
+			rangeReq = ""
+		}
+	}
+
+	if inm := r.Header.Get("If-None-Match"); inm != "" {
+		// Must know ETag.
+		if etag == "" {
+			return rangeReq, false
+		}
+
+		// TODO(bradfitz): non-GET/HEAD requests require more work:
+		// sending a different status code on matches, and
+		// also can't use weak cache validators (those with a "W/
+		// prefix).  But most users of ServeContent will be using
+		// it on GET or HEAD, so only support those for now.
+		if r.Method != "GET" && r.Method != "HEAD" {
+			return rangeReq, false
+		}
+
+		// TODO(bradfitz): deal with comma-separated or multiple-valued
+		// list of If-None-match values.  For now just handle the common
+		// case of a single item.
+		if inm == etag || inm == "*" {
+			h := w.Header()
+			delete(h, "Content-Type")
+			delete(h, "Content-Length")
+			w.WriteHeader(http.StatusNotModified)
+			return "", true
+		}
+	}
+	return rangeReq, false
+}
+
+// httpRange specifies the byte range to be sent to the client.
+type httpRange struct {
+	start, length int64
+}
+
+func (r httpRange) contentRange(size int64) string {
+	return fmt.Sprintf("bytes %d-%d/%d", r.start, r.start+r.length-1, size)
+}
+
+func (r httpRange) mimeHeader(contentType string, size int64) textproto.MIMEHeader {
+	return textproto.MIMEHeader{
+		"Content-Range": {r.contentRange(size)},
+		"Content-Type":  {contentType},
+	}
+}
+
+// parseRange parses a Range header string as per RFC 2616.
+func parseRange(s string, size int64) ([]httpRange, error) {
+	if s == "" {
+		return nil, nil // header not present
+	}
+	const b = "bytes="
+	if !strings.HasPrefix(s, b) {
+		return nil, errors.New("invalid range")
+	}
+	var ranges []httpRange
+	for _, ra := range strings.Split(s[len(b):], ",") {
+		ra = strings.TrimSpace(ra)
+		if ra == "" {
+			continue
+		}
+		i := strings.Index(ra, "-")
+		if i < 0 {
+			return nil, errors.New("invalid range")
+		}
+		start, end := strings.TrimSpace(ra[:i]), strings.TrimSpace(ra[i+1:])
+		var r httpRange
+		if start == "" {
+			// If no start is specified, end specifies the
+			// range start relative to the end of the file.
+			i, err := strconv.ParseInt(end, 10, 64)
+			if err != nil {
+				return nil, errors.New("invalid range")
+			}
+			if i > size {
+				i = size
+			}
+			r.start = size - i
+			r.length = size - r.start
+		} else {
+			i, err := strconv.ParseInt(start, 10, 64)
+			if err != nil || i >= size || i < 0 {
+				return nil, errors.New("invalid range")
+			}
+			r.start = i
+			if end == "" {
+				// If no end is specified, range extends to end of the file.
+				r.length = size - r.start
+			} else {
+				i, err := strconv.ParseInt(end, 10, 64)
+				if err != nil || r.start > i {
+					return nil, errors.New("invalid range")
+				}
+				if i >= size {
+					i = size - 1
+				}
+				r.length = i - r.start + 1
+			}
+		}
+		ranges = append(ranges, r)
+	}
+	return ranges, nil
+}
+
+// countingWriter counts how many bytes have been written to it.
+type countingWriter int64
+
+func (w *countingWriter) Write(p []byte) (n int, err error) {
+	*w += countingWriter(len(p))
+	return len(p), nil
+}
+
+// rangesMIMESize returns the number of bytes it takes to encode the
+// provided ranges as a multipart response.
+func rangesMIMESize(ranges []httpRange, contentType string, contentSize int64) (encSize int64) {
+	var w countingWriter
+	mw := multipart.NewWriter(&w)
+	for _, ra := range ranges {
+		mw.CreatePart(ra.mimeHeader(contentType, contentSize))
+		encSize += ra.length
+	}
+	mw.Close()
+	encSize += int64(w)
+	return
+}
+
+func sumRangesSize(ranges []httpRange) (size int64) {
+	for _, ra := range ranges {
+		size += ra.length
+	}
+	return
+}
+
+//文件下载功能。
+func (this *MatterService) DownloadFile(w http.ResponseWriter, r *http.Request, matter *Matter, content *os.File) {
+
+	//显示文件大小。
+	fileInfo, err := content.Stat()
+	if err != nil {
+		panic(err)
+	}
+
+	modtime := fileInfo.ModTime()
+
+	if checkLastModified(w, r, modtime) {
+		return
+	}
+	rangeReq, done := checkETag(w, r, modtime)
+	if done {
+		return
+	}
+
+	code := http.StatusOK
+
+	// From net/http/sniff.go
+	// The algorithm uses at most sniffLen bytes to make its decision.
+	const sniffLen = 512
+
+	// If Content-Type isn't set, use the file's extension to find it, but
+	// if the Content-Type is unset explicitly, do not sniff the type.
+	ctypes, haveType := w.Header()["Content-Type"]
+	var ctype string
+	if !haveType {
+		ctype = mime.TypeByExtension(filepath.Ext(fileInfo.Name()))
+		if ctype == "" {
+			// read a chunk to decide between utf-8 text and binary
+			var buf [sniffLen]byte
+			n, _ := io.ReadFull(content, buf[:])
+			ctype = http.DetectContentType(buf[:n])
+			_, err := content.Seek(0, os.SEEK_SET) // rewind to output whole file
+			if err != nil {
+				this.PanicWebError("无法准确定位文件", http.StatusInternalServerError)
+				return
+			}
+		}
+		w.Header().Set("Content-Type", ctype)
+	} else if len(ctypes) > 0 {
+		ctype = ctypes[0]
+	}
+
+	size := fileInfo.Size()
+
+	// handle Content-Range header.
+	sendSize := size
+	var sendContent io.Reader = content
+	if size >= 0 {
+		ranges, err := parseRange(rangeReq, size)
+		if err != nil {
+			panic("range header出错")
+			this.PanicWebError("range header error", http.StatusRequestedRangeNotSatisfiable)
+			return
+		}
+		if sumRangesSize(ranges) > size {
+			// The total number of bytes in all the ranges
+			// is larger than the size of the file by
+			// itself, so this is probably an attack, or a
+			// dumb client.  Ignore the range request.
+			ranges = nil
+		}
+		switch {
+		case len(ranges) == 1:
+			// RFC 2616, Section 14.16:
+			// "When an HTTP message includes the content of a single
+			// range (for example, a response to a request for a
+			// single range, or to a request for a set of ranges
+			// that overlap without any holes), this content is
+			// transmitted with a Content-Range header, and a
+			// Content-Length header showing the number of bytes
+			// actually transferred.
+			// ...
+			// A response to a request for a single range MUST NOT
+			// be sent using the multipart/byteranges media type."
+			ra := ranges[0]
+			if _, err := content.Seek(ra.start, os.SEEK_SET); err != nil {
+				this.PanicWebError(err.Error(), http.StatusRequestedRangeNotSatisfiable)
+				return
+			}
+			sendSize = ra.length
+			code = http.StatusPartialContent
+			w.Header().Set("Content-Range", ra.contentRange(size))
+		case len(ranges) > 1:
+			sendSize = rangesMIMESize(ranges, ctype, size)
+			code = http.StatusPartialContent
+
+			pr, pw := io.Pipe()
+			mw := multipart.NewWriter(pw)
+			w.Header().Set("Content-Type", "multipart/byteranges; boundary="+mw.Boundary())
+			sendContent = pr
+			defer pr.Close() // cause writing goroutine to fail and exit if CopyN doesn't finish.
+			go func() {
+				for _, ra := range ranges {
+					part, err := mw.CreatePart(ra.mimeHeader(ctype, size))
+					if err != nil {
+						pw.CloseWithError(err)
+						return
+					}
+					if _, err := content.Seek(ra.start, os.SEEK_SET); err != nil {
+						pw.CloseWithError(err)
+						return
+					}
+					if _, err := io.CopyN(part, content, ra.length); err != nil {
+						pw.CloseWithError(err)
+						return
+					}
+				}
+				mw.Close()
+				pw.Close()
+			}()
+		}
+
+		w.Header().Set("Accept-Ranges", "bytes")
+		if w.Header().Get("Content-Encoding") == "" {
+			w.Header().Set("Content-Length", strconv.FormatInt(sendSize, 10))
+		}
+	}
+
+	w.WriteHeader(code)
+
+	if r.Method != "HEAD" {
+		io.CopyN(w, sendContent, sendSize)
+	}
+
+}

rest/router.go

@@ -40,16 +40,28 @@ func (this *Router) GlobalPanicHandler(writer http.ResponseWriter, request *http
 
 		var webResult *WebResult = nil
 		if value, ok := err.(string); ok {
+			writer.WriteHeader(http.StatusBadRequest)
 			webResult = &WebResult{Code: RESULT_CODE_UTIL_EXCEPTION, Msg: value}
 		} else if value, ok := err.(int); ok {
+			writer.WriteHeader(http.StatusBadRequest)
 			webResult = ConstWebResult(value)
 		} else if value, ok := err.(*WebResult); ok {
+			writer.WriteHeader(http.StatusBadRequest)
 			webResult = value
 		} else if value, ok := err.(WebResult); ok {
+			writer.WriteHeader(http.StatusBadRequest)
 			webResult = &value
+		} else if value, ok := err.(*WebError); ok {
+			writer.WriteHeader(value.Code)
+			webResult = &WebResult{Code: RESULT_CODE_UTIL_EXCEPTION, Msg: value.Msg}
+		} else if value, ok := err.(WebError); ok {
+			writer.WriteHeader((&value).Code)
+			webResult = &WebResult{Code: RESULT_CODE_UTIL_EXCEPTION, Msg: (&value).Msg}
 		} else if value, ok := err.(error); ok {
+			writer.WriteHeader(http.StatusBadRequest)
 			webResult = &WebResult{Code: RESULT_CODE_UTIL_EXCEPTION, Msg: value.Error()}
 		} else {
+			writer.WriteHeader(http.StatusInternalServerError)
 			webResult = &WebResult{Code: RESULT_CODE_UTIL_EXCEPTION, Msg: "服务器未知错误"}
 		}
 
@@ -60,11 +72,6 @@ func (this *Router) GlobalPanicHandler(writer http.ResponseWriter, request *http
 		var json = jsoniter.ConfigCompatibleWithStandardLibrary
 		b, _ := json.Marshal(webResult)
 
-		if webResult.Code == RESULT_CODE_OK {
-			writer.WriteHeader(http.StatusOK)
-		} else {
-			writer.WriteHeader(http.StatusBadRequest)
-		}
 		fmt.Fprintf(writer, string(b))
 	}
 }

rest/web_error.go

@@ -0,0 +1,10 @@
+package rest
+
+type WebError struct {
+	Code int    `json:"code"`
+	Msg  string `json:"msg"`
+}
+
+func (this *WebError) Error() string {
+	return this.Msg
+}