Refine the structure of project.
This commit is contained in:
zicla
400
code/tool/cache/cache.go
vendored
Normal file
400
code/tool/cache/cache.go
vendored
Normal file
@ -0,0 +1,400 @@
|
||||
package cache
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"fmt"
|
||||
"sort"
|
||||
"sync"
|
||||
"tank/code/tool/util"
|
||||
"time"
|
||||
)
|
||||
|
||||
//缓存项
|
||||
//主要借鉴了cache2go https://github.com/muesli/cache2go
|
||||
type CacheItem struct {
|
||||
sync.RWMutex //读写锁
|
||||
//缓存键
|
||||
key interface{}
|
||||
//缓存值
|
||||
data interface{}
|
||||
// 缓存项的生命期
|
||||
duration time.Duration
|
||||
//创建时间
|
||||
createTime time.Time
|
||||
//最后访问时间
|
||||
accessTime time.Time
|
||||
//访问次数
|
||||
count int64
|
||||
// 在删除缓存项之前调用的回调函数
|
||||
deleteCallback func(key interface{})
|
||||
}
|
||||
|
||||
//新建一项缓存
|
||||
func NewCacheItem(key interface{}, duration time.Duration, data interface{}) *CacheItem {
|
||||
t := time.Now()
|
||||
return &CacheItem{
|
||||
key: key,
|
||||
duration: duration,
|
||||
createTime: t,
|
||||
accessTime: t,
|
||||
count: 0,
|
||||
deleteCallback: nil,
|
||||
data: data,
|
||||
}
|
||||
}
|
||||
|
||||
//手动获取一下，保持该项
|
||||
func (item *CacheItem) KeepAlive() {
|
||||
item.Lock()
|
||||
defer item.Unlock()
|
||||
item.accessTime = time.Now()
|
||||
item.count++
|
||||
}
|
||||
|
||||
//返回生命周期
|
||||
func (item *CacheItem) Duration() time.Duration {
|
||||
return item.duration
|
||||
}
|
||||
|
||||
//返回访问时间。可能并发，加锁
|
||||
func (item *CacheItem) AccessTime() time.Time {
|
||||
item.RLock()
|
||||
defer item.RUnlock()
|
||||
return item.accessTime
|
||||
}
|
||||
|
||||
//返回创建时间
|
||||
func (item *CacheItem) CreateTime() time.Time {
|
||||
return item.createTime
|
||||
}
|
||||
|
||||
//返回访问时间。可能并发，加锁
|
||||
func (item *CacheItem) Count() int64 {
|
||||
item.RLock()
|
||||
defer item.RUnlock()
|
||||
return item.count
|
||||
}
|
||||
|
||||
//返回key值
|
||||
func (item *CacheItem) Key() interface{} {
|
||||
return item.key
|
||||
}
|
||||
|
||||
//返回数据
|
||||
func (item *CacheItem) Data() interface{} {
|
||||
return item.data
|
||||
}
|
||||
|
||||
//设置回调函数
|
||||
func (item *CacheItem) SetDeleteCallback(f func(interface{})) {
|
||||
item.Lock()
|
||||
defer item.Unlock()
|
||||
item.deleteCallback = f
|
||||
}
|
||||
|
||||
// 统一管理缓存项的表
|
||||
type CacheTable struct {
|
||||
sync.RWMutex
|
||||
|
||||
//所有缓存项
|
||||
items map[interface{}]*CacheItem
|
||||
// 触发缓存清理的定时器
|
||||
cleanupTimer *time.Timer
|
||||
// 缓存清理周期
|
||||
cleanupInterval time.Duration
|
||||
// 获取一个不存在的缓存项时的回调函数
|
||||
loadData func(key interface{}, args ...interface{}) *CacheItem
|
||||
// 向缓存表增加缓存项时的回调函数
|
||||
addedCallback func(item *CacheItem)
|
||||
// 从缓存表删除一个缓存项时的回调函数
|
||||
deleteCallback func(item *CacheItem)
|
||||
}
|
||||
|
||||
// 返回缓存中存储有多少项
|
||||
func (table *CacheTable) Count() int {
|
||||
table.RLock()
|
||||
defer table.RUnlock()
|
||||
return len(table.items)
|
||||
}
|
||||
|
||||
// 遍历所有项
|
||||
func (table *CacheTable) Foreach(trans func(key interface{}, item *CacheItem)) {
|
||||
table.RLock()
|
||||
defer table.RUnlock()
|
||||
|
||||
for k, v := range table.items {
|
||||
trans(k, v)
|
||||
}
|
||||
}
|
||||
|
||||
// SetDataLoader配置一个数据加载的回调，当尝试去请求一个不存在的key的时候调用
|
||||
func (table *CacheTable) SetDataLoader(f func(interface{}, ...interface{}) *CacheItem) {
|
||||
table.Lock()
|
||||
defer table.Unlock()
|
||||
table.loadData = f
|
||||
}
|
||||
|
||||
// 添加时的回调函数
|
||||
func (table *CacheTable) SetAddedCallback(f func(*CacheItem)) {
|
||||
table.Lock()
|
||||
defer table.Unlock()
|
||||
table.addedCallback = f
|
||||
}
|
||||
|
||||
// 删除时的回调函数
|
||||
func (table *CacheTable) SetDeleteCallback(f func(*CacheItem)) {
|
||||
table.Lock()
|
||||
defer table.Unlock()
|
||||
table.deleteCallback = f
|
||||
}
|
||||
|
||||
//终结检查，被自调整的时间触发
|
||||
func (table *CacheTable) checkExpire() {
|
||||
table.Lock()
|
||||
if table.cleanupTimer != nil {
|
||||
table.cleanupTimer.Stop()
|
||||
}
|
||||
if table.cleanupInterval > 0 {
|
||||
table.log("Expiration check triggered after %v for table", table.cleanupInterval)
|
||||
} else {
|
||||
table.log("Expiration check installed for table")
|
||||
}
|
||||
|
||||
// 为了不抢占锁，采用临时的items.
|
||||
items := table.items
|
||||
table.Unlock()
|
||||
|
||||
//为了定时器更准确，我们需要在每一个循环中更新‘now’，不确定是否是有效率的。
|
||||
now := time.Now()
|
||||
smallestDuration := 0 * time.Second
|
||||
for key, item := range items {
|
||||
// 取出我们需要的东西，为了不抢占锁
|
||||
item.RLock()
|
||||
duration := item.duration
|
||||
accessTime := item.accessTime
|
||||
item.RUnlock()
|
||||
|
||||
// 0永久有效
|
||||
if duration == 0 {
|
||||
continue
|
||||
}
|
||||
if now.Sub(accessTime) >= duration {
|
||||
//缓存项已经过期
|
||||
_, e := table.Delete(key)
|
||||
if e != nil {
|
||||
table.log("删除缓存项时出错 %v", e.Error())
|
||||
}
|
||||
} else {
|
||||
//查找最靠近结束生命周期的项目
|
||||
if smallestDuration == 0 || duration-now.Sub(accessTime) < smallestDuration {
|
||||
smallestDuration = duration - now.Sub(accessTime)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// 为下次清理设置间隔，自触发机制
|
||||
table.Lock()
|
||||
table.cleanupInterval = smallestDuration
|
||||
if smallestDuration > 0 {
|
||||
table.cleanupTimer = time.AfterFunc(smallestDuration, func() {
|
||||
go util.SafeMethod(table.checkExpire)
|
||||
})
|
||||
}
|
||||
table.Unlock()
|
||||
}
|
||||
|
||||
// 添加缓存项
|
||||
func (table *CacheTable) Add(key interface{}, duration time.Duration, data interface{}) *CacheItem {
|
||||
item := NewCacheItem(key, duration, data)
|
||||
|
||||
// 将缓存项放入表中
|
||||
table.Lock()
|
||||
table.log("Adding item with key %v and lifespan of %v to table", key, duration)
|
||||
table.items[key] = item
|
||||
|
||||
// 取出需要的东西，释放锁
|
||||
expDur := table.cleanupInterval
|
||||
addedItem := table.addedCallback
|
||||
table.Unlock()
|
||||
|
||||
// 有回调函数便执行回调
|
||||
if addedItem != nil {
|
||||
addedItem(item)
|
||||
}
|
||||
|
||||
// 如果我们没有设置任何心跳检查定时器或者找一个即将迫近的项目
|
||||
if duration > 0 && (expDur == 0 || duration < expDur) {
|
||||
table.checkExpire()
|
||||
}
|
||||
|
||||
return item
|
||||
}
|
||||
|
||||
// 从缓存中删除项
|
||||
func (table *CacheTable) Delete(key interface{}) (*CacheItem, error) {
|
||||
table.RLock()
|
||||
r, ok := table.items[key]
|
||||
if !ok {
|
||||
table.RUnlock()
|
||||
return nil, errors.New(fmt.Sprintf("没有找到%s对应的记录", key))
|
||||
}
|
||||
|
||||
// 取出要用到的东西，释放锁
|
||||
deleteCallback := table.deleteCallback
|
||||
table.RUnlock()
|
||||
|
||||
// 调用删除回调函数
|
||||
if deleteCallback != nil {
|
||||
deleteCallback(r)
|
||||
}
|
||||
|
||||
r.RLock()
|
||||
defer r.RUnlock()
|
||||
if r.deleteCallback != nil {
|
||||
r.deleteCallback(key)
|
||||
}
|
||||
|
||||
table.Lock()
|
||||
defer table.Unlock()
|
||||
table.log("Deleting item with key %v created on %v and hit %v times from table", key, r.createTime, r.count)
|
||||
delete(table.items, key)
|
||||
|
||||
return r, nil
|
||||
}
|
||||
|
||||
//单纯的检查某个键是否存在
|
||||
func (table *CacheTable) Exists(key interface{}) bool {
|
||||
table.RLock()
|
||||
defer table.RUnlock()
|
||||
_, ok := table.items[key]
|
||||
|
||||
return ok
|
||||
}
|
||||
|
||||
//如果存在，返回false. 如果不存在,就去添加一个键，并且返回true
|
||||
func (table *CacheTable) NotFoundAdd(key interface{}, lifeSpan time.Duration, data interface{}) bool {
|
||||
table.Lock()
|
||||
|
||||
if _, ok := table.items[key]; ok {
|
||||
table.Unlock()
|
||||
return false
|
||||
}
|
||||
|
||||
item := NewCacheItem(key, lifeSpan, data)
|
||||
table.log("Adding item with key %v and lifespan of %v to table", key, lifeSpan)
|
||||
table.items[key] = item
|
||||
|
||||
// 取出需要的内容，释放锁
|
||||
expDur := table.cleanupInterval
|
||||
addedItem := table.addedCallback
|
||||
table.Unlock()
|
||||
|
||||
// 添加回调函数
|
||||
if addedItem != nil {
|
||||
addedItem(item)
|
||||
}
|
||||
|
||||
// 触发过期检查
|
||||
if lifeSpan > 0 && (expDur == 0 || lifeSpan < expDur) {
|
||||
table.checkExpire()
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
//从缓存中返回一个被标记的并保持活性的值。你可以传附件的参数到DataLoader回调函数
|
||||
func (table *CacheTable) Value(key interface{}, args ...interface{}) (*CacheItem, error) {
|
||||
table.RLock()
|
||||
r, ok := table.items[key]
|
||||
loadData := table.loadData
|
||||
table.RUnlock()
|
||||
|
||||
if ok {
|
||||
// 更新访问次数和访问时间
|
||||
r.KeepAlive()
|
||||
return r, nil
|
||||
}
|
||||
|
||||
// 有加载数据的方式，就通过loadData函数去加载进来
|
||||
if loadData != nil {
|
||||
item := loadData(key, args...)
|
||||
if item != nil {
|
||||
table.Add(key, item.duration, item.data)
|
||||
return item, nil
|
||||
}
|
||||
|
||||
return nil, errors.New("无法加载到缓存值")
|
||||
}
|
||||
|
||||
//没有找到任何东西，返回nil.
|
||||
return nil, nil
|
||||
}
|
||||
|
||||
// 删除缓存表中的所有项目
|
||||
func (table *CacheTable) Truncate() {
|
||||
table.Lock()
|
||||
defer table.Unlock()
|
||||
|
||||
table.log("Truncate table")
|
||||
|
||||
table.items = make(map[interface{}]*CacheItem)
|
||||
table.cleanupInterval = 0
|
||||
if table.cleanupTimer != nil {
|
||||
table.cleanupTimer.Stop()
|
||||
}
|
||||
}
|
||||
|
||||
//辅助table中排序，统计的
|
||||
type CacheItemPair struct {
|
||||
Key interface{}
|
||||
AccessCount int64
|
||||
}
|
||||
|
||||
type CacheItemPairList []CacheItemPair
|
||||
|
||||
func (p CacheItemPairList) Swap(i, j int) { p[i], p[j] = p[j], p[i] }
|
||||
func (p CacheItemPairList) Len() int { return len(p) }
|
||||
func (p CacheItemPairList) Less(i, j int) bool { return p[i].AccessCount > p[j].AccessCount }
|
||||
|
||||
// 返回缓存表中被访问最多的项目
|
||||
func (table *CacheTable) MostAccessed(count int64) []*CacheItem {
|
||||
table.RLock()
|
||||
defer table.RUnlock()
|
||||
|
||||
p := make(CacheItemPairList, len(table.items))
|
||||
i := 0
|
||||
for k, v := range table.items {
|
||||
p[i] = CacheItemPair{k, v.count}
|
||||
i++
|
||||
}
|
||||
sort.Sort(p)
|
||||
|
||||
var r []*CacheItem
|
||||
c := int64(0)
|
||||
for _, v := range p {
|
||||
if c >= count {
|
||||
break
|
||||
}
|
||||
|
||||
item, ok := table.items[v.Key]
|
||||
if ok {
|
||||
r = append(r, item)
|
||||
}
|
||||
c++
|
||||
}
|
||||
|
||||
return r
|
||||
}
|
||||
|
||||
|
||||
// 打印日志
|
||||
func (table *CacheTable) log(format string, v ...interface{}) {
|
||||
//TODO: 全局日志记录
|
||||
//LOGGER.Info(format, v...)
|
||||
}
|
||||
|
||||
//新建一个缓存Table
|
||||
func NewCacheTable() *CacheTable {
|
||||
return &CacheTable{
|
||||
items: make(map[interface{}]*CacheItem),
|
||||
}
|
||||
}
|
||||
@ -10,8 +10,8 @@ import (
|
||||
"fmt"
|
||||
"io"
|
||||
"net/http"
|
||||
"tank/code/result"
|
||||
"tank/code/tool/dav/xml"
|
||||
result2 "tank/code/tool/result"
|
||||
)
|
||||
|
||||
// Proppatch describes a property update instruction as defined in RFC 4918.
|
||||
@ -239,20 +239,20 @@ func ReadPropfind(reader io.Reader) (propfind *Propfind) {
|
||||
err = errInvalidPropfind
|
||||
}
|
||||
|
||||
panic(result.BadRequest(err.Error()))
|
||||
panic(result2.BadRequest(err.Error()))
|
||||
}
|
||||
|
||||
if propfind.Allprop == nil && propfind.Include != nil {
|
||||
panic(result.BadRequest(errInvalidPropfind.Error()))
|
||||
panic(result2.BadRequest(errInvalidPropfind.Error()))
|
||||
}
|
||||
if propfind.Allprop != nil && (propfind.Prop != nil || propfind.Propname != nil) {
|
||||
panic(result.BadRequest(errInvalidPropfind.Error()))
|
||||
panic(result2.BadRequest(errInvalidPropfind.Error()))
|
||||
}
|
||||
if propfind.Prop != nil && propfind.Propname != nil {
|
||||
panic(result.BadRequest(errInvalidPropfind.Error()))
|
||||
panic(result2.BadRequest(errInvalidPropfind.Error()))
|
||||
}
|
||||
if propfind.Propname == nil && propfind.Allprop == nil && propfind.Prop == nil {
|
||||
panic(result.BadRequest(errInvalidPropfind.Error()))
|
||||
panic(result2.BadRequest(errInvalidPropfind.Error()))
|
||||
}
|
||||
|
||||
return propfind
|
||||
|
||||
360
code/tool/download/download.go
Normal file
360
code/tool/download/download.go
Normal file
@ -0,0 +1,360 @@
|
||||
package download
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"fmt"
|
||||
"io"
|
||||
"mime/multipart"
|
||||
"net/http"
|
||||
"net/textproto"
|
||||
"net/url"
|
||||
"os"
|
||||
"strconv"
|
||||
"strings"
|
||||
"tank/code/tool/result"
|
||||
"tank/code/tool/util"
|
||||
"time"
|
||||
)
|
||||
|
||||
// HttpRange specifies the byte range to be sent to the client.
|
||||
type HttpRange struct {
|
||||
start int64
|
||||
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},
|
||||
}
|
||||
}
|
||||
|
||||
// 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
|
||||
}
|
||||
|
||||
//检查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
|
||||
}
|
||||
|
||||
// (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
|
||||
}
|
||||
|
||||
// (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
|
||||
}
|
||||
|
||||
// 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
|
||||
}
|
||||
|
||||
// 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 {
|
||||
_, e := mw.CreatePart(ra.mimeHeader(contentType, contentSize))
|
||||
|
||||
PanicError(e)
|
||||
|
||||
encSize += ra.length
|
||||
}
|
||||
e := mw.Close()
|
||||
PanicError(e)
|
||||
encSize += int64(w)
|
||||
return
|
||||
}
|
||||
|
||||
func SumRangesSize(ranges []HttpRange) (size int64) {
|
||||
for _, ra := range ranges {
|
||||
size += ra.length
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func PanicError(err error) {
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
}
|
||||
|
||||
//文件下载。具有进度功能。
|
||||
//下载功能参考：https://github.com/Masterminds/go-fileserver
|
||||
func DownloadFile(
|
||||
writer http.ResponseWriter,
|
||||
request *http.Request,
|
||||
filePath string,
|
||||
filename string,
|
||||
withContentDisposition bool) {
|
||||
|
||||
diskFile, err := os.Open(filePath)
|
||||
PanicError(err)
|
||||
|
||||
defer func() {
|
||||
e := diskFile.Close()
|
||||
PanicError(e)
|
||||
}()
|
||||
|
||||
//根据参数添加content-disposition。该Header会让浏览器自动下载，而不是预览。
|
||||
if withContentDisposition {
|
||||
fileName := url.QueryEscape(filename)
|
||||
writer.Header().Set("content-disposition", "attachment; filename=\""+fileName+"\"")
|
||||
}
|
||||
|
||||
//显示文件大小。
|
||||
fileInfo, err := diskFile.Stat()
|
||||
if err != nil {
|
||||
panic("无法从磁盘中获取文件信息")
|
||||
}
|
||||
|
||||
modifyTime := fileInfo.ModTime()
|
||||
|
||||
if CheckLastModified(writer, request, modifyTime) {
|
||||
return
|
||||
}
|
||||
rangeReq, done := CheckETag(writer, request, modifyTime)
|
||||
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 := writer.Header()["Content-Type"]
|
||||
var ctype string
|
||||
if !haveType {
|
||||
//使用mimeUtil来获取mime
|
||||
ctype = util.GetFallbackMimeType(filename, "")
|
||||
if ctype == "" {
|
||||
// read a chunk to decide between utf-8 text and binary
|
||||
var buf [sniffLen]byte
|
||||
n, _ := io.ReadFull(diskFile, buf[:])
|
||||
ctype = http.DetectContentType(buf[:n])
|
||||
_, err := diskFile.Seek(0, os.SEEK_SET) // rewind to output whole file
|
||||
if err != nil {
|
||||
panic("无法准确定位文件")
|
||||
}
|
||||
}
|
||||
writer.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 = diskFile
|
||||
if size >= 0 {
|
||||
ranges, err := ParseRange(rangeReq, size)
|
||||
if err != nil {
|
||||
panic(result.CustomWebResult(result.CODE_WRAPPER_RANGE_NOT_SATISFIABLE, "range header出错"))
|
||||
}
|
||||
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 := diskFile.Seek(ra.start, io.SeekStart); err != nil {
|
||||
panic(result.CustomWebResult(result.CODE_WRAPPER_RANGE_NOT_SATISFIABLE, "range header出错"))
|
||||
}
|
||||
sendSize = ra.length
|
||||
code = http.StatusPartialContent
|
||||
writer.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)
|
||||
writer.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 := diskFile.Seek(ra.start, io.SeekStart); err != nil {
|
||||
pw.CloseWithError(err)
|
||||
return
|
||||
}
|
||||
if _, err := io.CopyN(part, diskFile, ra.length); err != nil {
|
||||
pw.CloseWithError(err)
|
||||
return
|
||||
}
|
||||
}
|
||||
mw.Close()
|
||||
pw.Close()
|
||||
}()
|
||||
}
|
||||
|
||||
writer.Header().Set("Accept-Ranges", "bytes")
|
||||
if writer.Header().Get("Content-Encoding") == "" {
|
||||
writer.Header().Set("Content-Length", strconv.FormatInt(sendSize, 10))
|
||||
}
|
||||
}
|
||||
|
||||
writer.WriteHeader(code)
|
||||
|
||||
if request.Method != "HEAD" {
|
||||
io.CopyN(writer, sendContent, sendSize)
|
||||
}
|
||||
|
||||
}
|
||||
122
code/tool/result/web_result.go
Normal file
122
code/tool/result/web_result.go
Normal file
@ -0,0 +1,122 @@
|
||||
package result
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"net/http"
|
||||
)
|
||||
|
||||
type WebResult struct {
|
||||
Code string `json:"code"`
|
||||
Msg string `json:"msg"`
|
||||
Data interface{} `json:"data"`
|
||||
}
|
||||
|
||||
func (this *WebResult) Error() string {
|
||||
return this.Msg
|
||||
}
|
||||
|
||||
type CodeWrapper struct {
|
||||
Code string
|
||||
HttpStatus int
|
||||
Description string
|
||||
}
|
||||
|
||||
var (
|
||||
CODE_WRAPPER_OK = &CodeWrapper{Code: "OK", HttpStatus: http.StatusOK, Description: "成功"}
|
||||
CODE_WRAPPER_BAD_REQUEST = &CodeWrapper{Code: "BAD_REQUEST", HttpStatus: http.StatusBadRequest, Description: "请求不合法"}
|
||||
CODE_WRAPPER_CAPTCHA_ERROR = &CodeWrapper{Code: "CAPTCHA_ERROR", HttpStatus: http.StatusBadRequest, Description: "验证码错误"}
|
||||
CODE_WRAPPER_NEED_CAPTCHA = &CodeWrapper{Code: "NEED_CAPTCHA", HttpStatus: http.StatusBadRequest, Description: "验证码必填"}
|
||||
CODE_WRAPPER_USERNAME_PASSWORD_ERROR = &CodeWrapper{Code: "USERNAME_PASSWORD_ERROR", HttpStatus: http.StatusBadRequest, Description: "用户名或密码错误"}
|
||||
CODE_WRAPPER_PARAMS_ERROR = &CodeWrapper{Code: "PARAMS_ERROR", HttpStatus: http.StatusBadRequest, Description: "用户名或密码错误"}
|
||||
CODE_WRAPPER_LOGIN = &CodeWrapper{Code: "LOGIN", HttpStatus: http.StatusUnauthorized, Description: "未登录，禁止访问"}
|
||||
CODE_WRAPPER_LOGIN_EXPIRE = &CodeWrapper{Code: "LOGIN_EXPIRE", HttpStatus: http.StatusUnauthorized, Description: "登录过期，请重新登录"}
|
||||
CODE_WRAPPER_USER_DISABLED = &CodeWrapper{Code: "USER_DISABLED", HttpStatus: http.StatusForbidden, Description: "账户被禁用，禁止访问"}
|
||||
CODE_WRAPPER_UNAUTHORIZED = &CodeWrapper{Code: "UNAUTHORIZED", HttpStatus: http.StatusUnauthorized, Description: "没有权限，禁止访问"}
|
||||
CODE_WRAPPER_NOT_FOUND = &CodeWrapper{Code: "NOT_FOUND", HttpStatus: http.StatusNotFound, Description: "内容不存在"}
|
||||
CODE_WRAPPER_RANGE_NOT_SATISFIABLE = &CodeWrapper{Code: "RANGE_NOT_SATISFIABLE", HttpStatus: http.StatusRequestedRangeNotSatisfiable, Description: "文件范围读取错误"}
|
||||
CODE_WRAPPER_NOT_INSTALLED = &CodeWrapper{Code: "NOT_INSTALLED", HttpStatus: http.StatusInternalServerError, Description: "系统尚未安装"}
|
||||
CODE_WRAPPER_SERVER = &CodeWrapper{Code: "SERVER", HttpStatus: http.StatusInternalServerError, Description: "服务器出错"}
|
||||
CODE_WRAPPER_UNKNOWN = &CodeWrapper{Code: "UNKNOWN", HttpStatus: http.StatusInternalServerError, Description: "服务器未知错误"}
|
||||
)
|
||||
|
||||
//根据 CodeWrapper来获取对应的HttpStatus
|
||||
func FetchHttpStatus(code string) int {
|
||||
if code == CODE_WRAPPER_OK.Code {
|
||||
return CODE_WRAPPER_OK.HttpStatus
|
||||
} else if code == CODE_WRAPPER_BAD_REQUEST.Code {
|
||||
return CODE_WRAPPER_BAD_REQUEST.HttpStatus
|
||||
} else if code == CODE_WRAPPER_CAPTCHA_ERROR.Code {
|
||||
return CODE_WRAPPER_CAPTCHA_ERROR.HttpStatus
|
||||
} else if code == CODE_WRAPPER_NEED_CAPTCHA.Code {
|
||||
return CODE_WRAPPER_NEED_CAPTCHA.HttpStatus
|
||||
} else if code == CODE_WRAPPER_USERNAME_PASSWORD_ERROR.Code {
|
||||
return CODE_WRAPPER_USERNAME_PASSWORD_ERROR.HttpStatus
|
||||
} else if code == CODE_WRAPPER_PARAMS_ERROR.Code {
|
||||
return CODE_WRAPPER_PARAMS_ERROR.HttpStatus
|
||||
} else if code == CODE_WRAPPER_LOGIN.Code {
|
||||
return CODE_WRAPPER_LOGIN.HttpStatus
|
||||
} else if code == CODE_WRAPPER_LOGIN_EXPIRE.Code {
|
||||
return CODE_WRAPPER_LOGIN_EXPIRE.HttpStatus
|
||||
} else if code == CODE_WRAPPER_USER_DISABLED.Code {
|
||||
return CODE_WRAPPER_USER_DISABLED.HttpStatus
|
||||
} else if code == CODE_WRAPPER_UNAUTHORIZED.Code {
|
||||
return CODE_WRAPPER_UNAUTHORIZED.HttpStatus
|
||||
} else if code == CODE_WRAPPER_NOT_FOUND.Code {
|
||||
return CODE_WRAPPER_NOT_FOUND.HttpStatus
|
||||
} else if code == CODE_WRAPPER_RANGE_NOT_SATISFIABLE.Code {
|
||||
return CODE_WRAPPER_RANGE_NOT_SATISFIABLE.HttpStatus
|
||||
} else if code == CODE_WRAPPER_NOT_INSTALLED.Code {
|
||||
return CODE_WRAPPER_NOT_INSTALLED.HttpStatus
|
||||
} else if code == CODE_WRAPPER_SERVER.Code {
|
||||
return CODE_WRAPPER_SERVER.HttpStatus
|
||||
} else {
|
||||
return CODE_WRAPPER_UNKNOWN.HttpStatus
|
||||
}
|
||||
}
|
||||
|
||||
func ConstWebResult(codeWrapper *CodeWrapper) *WebResult {
|
||||
|
||||
wr := &WebResult{
|
||||
Code: codeWrapper.Code,
|
||||
Msg: codeWrapper.Description,
|
||||
}
|
||||
return wr
|
||||
}
|
||||
|
||||
func CustomWebResult(codeWrapper *CodeWrapper, description string) *WebResult {
|
||||
|
||||
wr := &WebResult{
|
||||
Code: codeWrapper.Code,
|
||||
Msg: description,
|
||||
}
|
||||
return wr
|
||||
}
|
||||
|
||||
//请求参数有问题
|
||||
func BadRequest(format string, v ...interface{}) *WebResult {
|
||||
return CustomWebResult(CODE_WRAPPER_BAD_REQUEST, fmt.Sprintf(format, v...))
|
||||
}
|
||||
|
||||
//没有权限
|
||||
func Unauthorized(format string, v ...interface{}) *WebResult {
|
||||
return CustomWebResult(CODE_WRAPPER_UNAUTHORIZED, fmt.Sprintf(format, v...))
|
||||
}
|
||||
|
||||
//没有找到
|
||||
func NotFound(format string, v ...interface{}) *WebResult {
|
||||
return CustomWebResult(CODE_WRAPPER_NOT_FOUND, fmt.Sprintf(format, v...))
|
||||
|
||||
}
|
||||
|
||||
//服务器内部出问题
|
||||
func Server(format string, v ...interface{}) *WebResult {
|
||||
return CustomWebResult(CODE_WRAPPER_SERVER, fmt.Sprintf(format, v...))
|
||||
}
|
||||
|
||||
//所有的数据库错误情况
|
||||
var (
|
||||
DB_ERROR_DUPLICATE_KEY = "Error 1062: Duplicate entry"
|
||||
DB_ERROR_NOT_FOUND = "record not found"
|
||||
DB_TOO_MANY_CONNECTIONS = "Error 1040: Too many connections"
|
||||
DB_BAD_CONNECTION = "driver: bad connection"
|
||||
)
|
||||
@ -9,7 +9,7 @@ import (
|
||||
"os/user"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
"tank/code/result"
|
||||
result2 "tank/code/tool/result"
|
||||
)
|
||||
|
||||
//判断文件或文件夹是否已经存在
|
||||
@ -126,13 +126,13 @@ func GetFilenameOfPath(fullPath string) string {
|
||||
func DeleteEmptyDir(dirPath string) bool {
|
||||
dir, err := ioutil.ReadDir(dirPath)
|
||||
if err != nil {
|
||||
panic(result.BadRequest("尝试读取目录%s时出错 %s", dirPath, err.Error()))
|
||||
panic(result2.BadRequest("尝试读取目录%s时出错 %s", dirPath, err.Error()))
|
||||
}
|
||||
if len(dir) == 0 {
|
||||
//空文件夹
|
||||
err = os.Remove(dirPath)
|
||||
if err != nil {
|
||||
panic(result.BadRequest("删除磁盘上的文件夹%s出错 %s", dirPath, err.Error()))
|
||||
panic(result2.BadRequest("删除磁盘上的文件夹%s出错 %s", dirPath, err.Error()))
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user