Beego/cache/file.go

/**
 * package: file
 * User: gouki
 * Date: 2013-10-22 - 14:22
 */
package cache

import (
	"bytes"
	"crypto/md5"
	"encoding/gob"
	"encoding/hex"
	"encoding/json"
	"fmt"
	"io"
	"os"
	"path"
	"reflect"
	"strconv"
	"time"
)

func init() {
	Register("file", NewFileCache())
}

type FileCacheItem struct {
	Data       interface{}
	Lastaccess int64
	Expired    int64
}

var (
	FileCachePath           string = "cache"
	FileCacheFileSuffix     string = ".bin"
	FileCacheDirectoryLevel int    = 2
	/**
	 * 默认永不过期
	 */
	FileCacheEmbedExpiry int64 = 0
)

type FileCache struct {
	CachePath      string
	FileSuffix     string
	DirectoryLevel int
	EmbedExpiry    int
}

func NewFileCache() *FileCache {
	//    return &FileCache{CachePath:FileCachePath, FileSuffix:FileCacheFileSuffix}
	return &FileCache{}
}

func (this *FileCache) StartAndGC(config string) error {

	var cfg map[string]string
	json.Unmarshal([]byte(config), &cfg)
	//fmt.Println(cfg)
	if _, ok := cfg["CachePath"]; !ok {
		cfg["CachePath"] = FileCachePath
	}
	if _, ok := cfg["FileSuffix"]; !ok {
		cfg["FileSuffix"] = FileCacheFileSuffix
	}
	if _, ok := cfg["DirectoryLevel"]; !ok {
		cfg["DirectoryLevel"] = strconv.Itoa(FileCacheDirectoryLevel)
	}
	if _, ok := cfg["EmbedExpiry"]; !ok {
		cfg["EmbedExpiry"] = strconv.FormatInt(FileCacheEmbedExpiry, 10)
	}
	this.CachePath = cfg["CachePath"]
	this.FileSuffix = cfg["FileSuffix"]
	this.DirectoryLevel, _ = strconv.Atoi(cfg["DirectoryLevel"])
	this.EmbedExpiry, _ = strconv.Atoi(cfg["EmbedExpiry"])

	this.Init()
	return nil
}

func (this *FileCache) Init() {
	app := path.Dir(os.Args[0])
	this.CachePath = path.Join(app, this.CachePath)
	ok, err := exists(this.CachePath)
	if err != nil { // print error
		//fmt.Println(err)
	}
	if !ok {
		if err = os.Mkdir(this.CachePath, os.ModePerm); err != nil {
			//fmt.Println(err);
		}
	}
	//fmt.Println(this.getCacheFileName("123456"));
}

func (this *FileCache) getCacheFileName(key string) string {
	m := md5.New()
	io.WriteString(m, key)
	keyMd5 := hex.EncodeToString(m.Sum(nil))
	cachePath := this.CachePath
	//fmt.Println("cachepath : " , cachePath)
	//fmt.Println("md5" , keyMd5);
	switch this.DirectoryLevel {
	case 2:
		cachePath = path.Join(cachePath, keyMd5[0:2], keyMd5[2:4])
	case 1:
		cachePath = path.Join(cachePath, keyMd5[0:2])
	}

	ok, err := exists(cachePath)
	if err != nil {
		//fmt.Println(err)
	}
	if !ok {
		if err = os.MkdirAll(cachePath, os.ModePerm); err != nil {
			//fmt.Println(err);
		}
	}
	return path.Join(cachePath, fmt.Sprintf("%s%s", keyMd5, this.FileSuffix))
}

func (this *FileCache) Get(key string) interface{} {
	filename := this.getCacheFileName(key)
	filedata, err := File_get_contents(filename)
	//fmt.Println("get length:" , len(filedata));
	if err != nil {
		return ""
	}
	var to FileCacheItem
	Gob_decode([]byte(filedata), &to)
	if to.Expired < time.Now().Unix() {
		return ""
	}
	return to.Data
}

func (this *FileCache) Put(key string, val interface{}, timeout int64) error {
	filename := this.getCacheFileName(key)
	var item FileCacheItem
	item.Data = val
	if timeout == FileCacheEmbedExpiry {
		item.Expired = time.Now().Unix() + (86400 * 365 * 10) //10年
	} else {
		item.Expired = time.Now().Unix() + timeout
	}
	item.Lastaccess = time.Now().Unix()
	data, err := Gob_encode(item)
	if err != nil {
		return err
	}
	err = File_put_contents(filename, data)
	return err
}

func (this *FileCache) Delete(key string) error {
	filename := this.getCacheFileName(key)
	if ok, _ := exists(filename); ok {
		return os.Remove(filename)
	}
	return nil
}

func (this *FileCache) Incr(key string) error {
	data := this.Get(key)
	var incr int
	fmt.Println(reflect.TypeOf(data).Name())
	if reflect.TypeOf(data).Name() != "int" {
		incr = 0
	} else {
		incr = data.(int) + 1
	}
	this.Put(key, incr, FileCacheEmbedExpiry)
	return nil
}

func (this *FileCache) Decr(key string) error {
	data := this.Get(key)
	var decr int
	if reflect.TypeOf(data).Name() != "int" || data.(int)-1 <= 0 {
		decr = 0
	} else {
		decr = data.(int) - 1
	}
	this.Put(key, decr, FileCacheEmbedExpiry)
	return nil
}

func (this *FileCache) IsExist(key string) bool {
	filename := this.getCacheFileName(key)
	ret, _ := exists(filename)
	return ret
}

func (this *FileCache) ClearAll() error {
	//this.CachePath .递归删除

	return nil
}

func exists(path string) (bool, error) {
	_, err := os.Stat(path)
	if err == nil {
		return true, nil
	}
	if os.IsNotExist(err) {
		return false, nil
	}
	return false, err
}

func File_get_contents(filename string) ([]byte, error) { //文件不存在时自动创建
	f, err := os.OpenFile(filename, os.O_RDWR|os.O_CREATE, os.ModePerm)
	if err != nil {
		return []byte(""), err
	}
	defer f.Close()
	stat, err := f.Stat()
	if err != nil {
		return []byte(""), err
	}
	data := make([]byte, stat.Size())
	result, err := f.Read(data)
	if int64(result) == stat.Size() {
		return data, err
	}
	return []byte(""), err
}

func File_put_contents(filename string, content []byte) error {
	fp, err := os.OpenFile(filename, os.O_RDWR|os.O_CREATE, os.ModePerm)
	if err != nil {
		return err
	}
	defer fp.Close()
	_, err = fp.Write(content)
	return err
}
func Gob_encode(data interface{}) ([]byte, error) {
	buf := bytes.NewBuffer(nil)
	enc := gob.NewEncoder(buf)
	err := enc.Encode(data)
	if err != nil {
		return nil, err
	}
	return buf.Bytes(), err
}

func Gob_decode(data []byte, to interface{}) error {
	buf := bytes.NewBuffer(data)
	dec := gob.NewDecoder(buf)
	return dec.Decode(&to)
}