Keep refine the structure.
This commit is contained in:
zicla
@ -1,363 +0,0 @@
|
||||
package tool
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"fmt"
|
||||
"io"
|
||||
"mime/multipart"
|
||||
"net/http"
|
||||
"net/textproto"
|
||||
"net/url"
|
||||
"os"
|
||||
"strconv"
|
||||
"strings"
|
||||
"tank/rest/result"
|
||||
"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 = 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)
|
||||
}
|
||||
|
||||
}
|
||||
@ -1,160 +0,0 @@
|
||||
package tool
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"log"
|
||||
"os"
|
||||
"runtime"
|
||||
"sync"
|
||||
"time"
|
||||
)
|
||||
|
||||
//日志系统必须高保
|
||||
//全局唯一的日志对象(在main函数中初始化)
|
||||
var LOGGER = &Logger{}
|
||||
|
||||
//在Logger的基础上包装一个全新的Logger.
|
||||
type Logger struct {
|
||||
//加锁，在维护日志期间，禁止写入日志。
|
||||
sync.RWMutex
|
||||
|
||||
//继承logger
|
||||
goLogger *log.Logger
|
||||
//日志记录所在的文件
|
||||
file *os.File
|
||||
//每天凌晨定时整理器
|
||||
maintainTimer *time.Timer
|
||||
}
|
||||
|
||||
//处理日志的统一方法。
|
||||
func (this *Logger) log(prefix string, format string, v ...interface{}) {
|
||||
|
||||
content := fmt.Sprintf(format+"\r\n", v...)
|
||||
|
||||
//控制台中打印日志，记录行号。
|
||||
_, file, line, ok := runtime.Caller(2)
|
||||
if !ok {
|
||||
file = "???"
|
||||
line = 0
|
||||
}
|
||||
|
||||
var consoleFormat = fmt.Sprintf("%s%s %s:%d %s", prefix, ConvertTimeToTimeString(time.Now()), GetFilenameOfPath(file), line, content)
|
||||
fmt.Printf(consoleFormat)
|
||||
|
||||
this.goLogger.SetPrefix(prefix)
|
||||
|
||||
//每一行我们加上换行符
|
||||
err := this.goLogger.Output(3, content)
|
||||
if err != nil {
|
||||
fmt.Printf("occur error while logging %s \r\n", err.Error())
|
||||
}
|
||||
}
|
||||
|
||||
//处理日志的统一方法。
|
||||
func (this *Logger) Debug(format string, v ...interface{}) {
|
||||
this.log("[DEBUG]", format, v...)
|
||||
}
|
||||
|
||||
func (this *Logger) Info(format string, v ...interface{}) {
|
||||
this.log("[INFO ]", format, v...)
|
||||
}
|
||||
|
||||
func (this *Logger) Warn(format string, v ...interface{}) {
|
||||
this.log("[WARN ]", format, v...)
|
||||
}
|
||||
|
||||
func (this *Logger) Error(format string, v ...interface{}) {
|
||||
this.log("[ERROR]", format, v...)
|
||||
}
|
||||
|
||||
func (this *Logger) Panic(format string, v ...interface{}) {
|
||||
this.log("[PANIC]", format, v...)
|
||||
panic(fmt.Sprintf(format, v...))
|
||||
}
|
||||
|
||||
func (this *Logger) Init() {
|
||||
|
||||
this.openFile()
|
||||
|
||||
//日志需要自我备份，自我维护。明天第一秒触发
|
||||
nextTime := FirstSecondOfDay(Tomorrow())
|
||||
duration := nextTime.Sub(time.Now())
|
||||
|
||||
this.Info("下一次日志维护时间%s 距当前 %ds ", ConvertTimeToDateTimeString(nextTime), duration/time.Second)
|
||||
this.maintainTimer = time.AfterFunc(duration, func() {
|
||||
go SafeMethod(this.maintain)
|
||||
})
|
||||
|
||||
}
|
||||
|
||||
//将日志写入到今天的日期中(该方法内必须使用异步方法记录日志，否则会引发死锁)
|
||||
func (this *Logger) maintain() {
|
||||
|
||||
this.Info("每日维护日志")
|
||||
|
||||
this.Lock()
|
||||
defer this.Unlock()
|
||||
|
||||
//首先关闭文件。
|
||||
this.closeFile()
|
||||
|
||||
//日志归类到昨天
|
||||
destPath := GetLogPath() + "/tank-" + Yesterday().Local().Format("2006-01-02") + ".log"
|
||||
|
||||
//直接重命名文件
|
||||
err := os.Rename(this.fileName(), destPath)
|
||||
if err != nil {
|
||||
this.Error("重命名文件出错", err.Error())
|
||||
}
|
||||
|
||||
//再次打开文件
|
||||
this.openFile()
|
||||
|
||||
//准备好下次维护日志的时间。
|
||||
now := time.Now()
|
||||
nextTime := FirstSecondOfDay(Tomorrow())
|
||||
duration := nextTime.Sub(now)
|
||||
this.Info("下次维护时间：%s ", ConvertTimeToDateTimeString(nextTime))
|
||||
this.maintainTimer = time.AfterFunc(duration, func() {
|
||||
go SafeMethod(this.maintain)
|
||||
})
|
||||
}
|
||||
|
||||
//日志名称
|
||||
func (this *Logger) fileName() string {
|
||||
return GetLogPath() + "/tank.log"
|
||||
}
|
||||
|
||||
//打开日志文件
|
||||
func (this *Logger) openFile() {
|
||||
//日志输出到文件中 文件打开后暂时不关闭
|
||||
fmt.Printf("使用日志文件 %s\r\n", this.fileName())
|
||||
f, err := os.OpenFile(this.fileName(), os.O_RDWR|os.O_CREATE|os.O_APPEND, 0666)
|
||||
if err != nil {
|
||||
panic("日志文件无法正常打开: " + err.Error())
|
||||
}
|
||||
|
||||
this.goLogger = log.New(f, "", log.Ltime|log.Lshortfile)
|
||||
|
||||
this.file = f
|
||||
}
|
||||
|
||||
//关闭日志文件
|
||||
func (this *Logger) closeFile() {
|
||||
if this.file != nil {
|
||||
err := this.file.Close()
|
||||
if err != nil {
|
||||
panic("尝试关闭日志时出错: " + err.Error())
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func (this *Logger) Destroy() {
|
||||
|
||||
this.closeFile()
|
||||
|
||||
if this.maintainTimer != nil {
|
||||
this.maintainTimer.Stop()
|
||||
}
|
||||
|
||||
}
|
||||
@ -1,399 +0,0 @@
|
||||
package tool
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"fmt"
|
||||
"sort"
|
||||
"sync"
|
||||
"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 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{}) {
|
||||
//全局日志记录
|
||||
//LOGGER.Info(format, v...)
|
||||
}
|
||||
|
||||
//新建一个缓存Table
|
||||
func NewCacheTable() *CacheTable {
|
||||
return &CacheTable{
|
||||
items: make(map[interface{}]*CacheItem),
|
||||
}
|
||||
}
|
||||
@ -9,6 +9,7 @@ import (
|
||||
"os/user"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
"tank/rest/result"
|
||||
)
|
||||
|
||||
//判断文件或文件夹是否已经存在
|
||||
@ -125,19 +126,17 @@ func GetFilenameOfPath(fullPath string) string {
|
||||
func DeleteEmptyDir(dirPath string) bool {
|
||||
dir, err := ioutil.ReadDir(dirPath)
|
||||
if err != nil {
|
||||
LOGGER.Error("尝试读取目录%s时出错 %s", dirPath, err.Error())
|
||||
panic("尝试读取目录时出错 " + err.Error())
|
||||
panic(result.BadRequest("尝试读取目录%s时出错 %s", dirPath, err.Error()))
|
||||
}
|
||||
if len(dir) == 0 {
|
||||
//空文件夹
|
||||
err = os.Remove(dirPath)
|
||||
if err != nil {
|
||||
LOGGER.Error("删除磁盘上的文件夹%s出错 %s", dirPath, err.Error())
|
||||
panic(result.BadRequest("删除磁盘上的文件夹%s出错 %s", dirPath, err.Error()))
|
||||
}
|
||||
return true
|
||||
} else {
|
||||
LOGGER.Info("文件夹不为空，%v", len(dir))
|
||||
}
|
||||
|
||||
return false
|
||||
}
|
||||
|
||||
@ -215,7 +214,6 @@ func GetLogPath() string {
|
||||
return filePath
|
||||
}
|
||||
|
||||
|
||||
//复制文件
|
||||
func CopyFile(srcPath string, destPath string) (nBytes int64) {
|
||||
|
||||
|
||||
Reference in New Issue
Block a user