code tidy up
logger tidy up private serialize and deserialize func
This commit is contained in:
Nash Tsai
parent
236970548e
commit
a562f9b6aa
106
redis_cacher.go
106
redis_cacher.go
|
|
@ -6,15 +6,16 @@ import (
|
|||
"fmt"
|
||||
"github.com/garyburd/redigo/redis"
|
||||
//"github.com/go-xorm/core"
|
||||
"hash/crc32"
|
||||
"log"
|
||||
"reflect"
|
||||
"strconv"
|
||||
// "strconv"
|
||||
"time"
|
||||
)
|
||||
|
||||
const (
|
||||
DEFAULT = time.Duration(0)
|
||||
FOREVER = time.Duration(-1)
|
||||
DEFAULT_EXPIRATION = time.Duration(0)
|
||||
FOREVER_EXPIRATION = time.Duration(-1)
|
||||
)
|
||||
|
||||
// Wraps the Redis client to meet the Cache interface.
|
||||
|
|
@ -69,7 +70,9 @@ func (c *RedisCacher) getBeanKey(tableName string, id string) string {
|
|||
}
|
||||
|
||||
func (c *RedisCacher) getSqlKey(tableName string, sql string) string {
|
||||
return fmt.Sprintf("sql:%s:%s", tableName, sql)
|
||||
// hash sql to minimize key length
|
||||
crc := crc32.ChecksumIEEE([]byte(sql))
|
||||
return fmt.Sprintf("sql:%s:%d", tableName, crc)
|
||||
}
|
||||
|
||||
func (c *RedisCacher) Flush() error {
|
||||
|
|
@ -80,7 +83,6 @@ func (c *RedisCacher) Flush() error {
|
|||
}
|
||||
|
||||
func (c *RedisCacher) getObject(key string) interface{} {
|
||||
|
||||
conn := c.pool.Get()
|
||||
defer conn.Close()
|
||||
raw, err := conn.Do("GET", key)
|
||||
|
|
@ -89,21 +91,23 @@ func (c *RedisCacher) getObject(key string) interface{} {
|
|||
}
|
||||
item, err := redis.Bytes(raw, err)
|
||||
if err != nil {
|
||||
log.Fatalf("xorm/cache: redis.Bytes failed: %s", err)
|
||||
log.Fatalf("[xorm/redis_cacher] redis.Bytes failed: %s", err)
|
||||
return nil
|
||||
}
|
||||
|
||||
value, err := Deserialize(item)
|
||||
value, err := deserialize(item)
|
||||
|
||||
return value
|
||||
}
|
||||
|
||||
func (c *RedisCacher) GetIds(tableName, sql string) interface{} {
|
||||
log.Printf("[xorm/redis_cacher] GetIds|tableName:%s|sql:%s", tableName, sql)
|
||||
|
||||
return c.getObject(c.getSqlKey(tableName, sql))
|
||||
}
|
||||
|
||||
func (c *RedisCacher) GetBean(tableName string, id string) interface{} {
|
||||
log.Printf("[xorm/redis_cacher] GetBean|tableName:%s|id:%s", tableName, id)
|
||||
return c.getObject(c.getBeanKey(tableName, id))
|
||||
}
|
||||
|
||||
|
|
@ -112,10 +116,13 @@ func (c *RedisCacher) putObject(key string, value interface{}) {
|
|||
}
|
||||
|
||||
func (c *RedisCacher) PutIds(tableName, sql string, ids interface{}) {
|
||||
c.putObject(c.getBeanKey(tableName, sql), ids)
|
||||
log.Printf("[xorm/redis_cacher] PutIds|tableName:%s|sql:%s|type:%v", tableName, sql, reflect.TypeOf(ids))
|
||||
|
||||
c.putObject(c.getSqlKey(tableName, sql), ids)
|
||||
}
|
||||
|
||||
func (c *RedisCacher) PutBean(tableName string, id string, obj interface{}) {
|
||||
log.Printf("[xorm/redis_cacher] PutBean|tableName:%s|id:%s|type:%v", tableName, id, reflect.TypeOf(obj))
|
||||
c.putObject(c.getBeanKey(tableName, id), obj)
|
||||
}
|
||||
|
||||
|
|
@ -133,7 +140,6 @@ func (c *RedisCacher) delObject(key string) {
|
|||
|
||||
func (c *RedisCacher) DelIds(tableName, sql string) {
|
||||
c.delObject(c.getSqlKey(tableName, sql))
|
||||
// TODO
|
||||
}
|
||||
|
||||
func (c *RedisCacher) DelBean(tableName string, id string) {
|
||||
|
|
@ -165,13 +171,13 @@ func (c *RedisCacher) invoke(f func(string, ...interface{}) (interface{}, error)
|
|||
key string, value interface{}, expires time.Duration) error {
|
||||
|
||||
switch expires {
|
||||
case DEFAULT:
|
||||
case DEFAULT_EXPIRATION:
|
||||
expires = c.defaultExpiration
|
||||
case FOREVER:
|
||||
case FOREVER_EXPIRATION:
|
||||
expires = time.Duration(0)
|
||||
}
|
||||
|
||||
b, err := Serialize(value)
|
||||
b, err := serialize(value)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
|
@ -186,72 +192,28 @@ func (c *RedisCacher) invoke(f func(string, ...interface{}) (interface{}, error)
|
|||
}
|
||||
}
|
||||
|
||||
// Serialize transforms the given value into bytes following these rules:
|
||||
// - If value is a byte array, it is returned as-is.
|
||||
// - If value is an int or uint type, it is returned as the ASCII representation
|
||||
// - Else, encoding/gob is used to serialize
|
||||
func Serialize(value interface{}) ([]byte, error) {
|
||||
if bytes, ok := value.([]byte); ok {
|
||||
return bytes, nil
|
||||
}
|
||||
|
||||
switch v := reflect.ValueOf(value); v.Kind() {
|
||||
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
|
||||
return []byte(strconv.FormatInt(v.Int(), 10)), nil
|
||||
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
|
||||
return []byte(strconv.FormatUint(v.Uint(), 10)), nil
|
||||
}
|
||||
func serialize(value interface{}) ([]byte, error) {
|
||||
|
||||
RegisterGobConcreteType(value)
|
||||
|
||||
var b bytes.Buffer
|
||||
encoder := gob.NewEncoder(&b)
|
||||
if err := interfaceEncode(encoder, value); err != nil {
|
||||
log.Fatalf("xorm/cache: gob encoding '%s' failed: %s", value, err)
|
||||
log.Fatalf("[xorm/redis_cacher] gob encoding '%s' failed: %s", value, err)
|
||||
return nil, err
|
||||
}
|
||||
return b.Bytes(), nil
|
||||
}
|
||||
|
||||
// Deserialize transforms bytes produced by Serialize back into a Go object,
|
||||
// storing it into "ptr", which must be a pointer to the value type.
|
||||
func Deserialize(byt []byte) (ptr interface{}, err error) {
|
||||
if bytes, ok := ptr.(*[]byte); ok {
|
||||
*bytes = byt
|
||||
return
|
||||
}
|
||||
|
||||
if v := reflect.ValueOf(ptr); v.Kind() == reflect.Ptr {
|
||||
switch p := v.Elem(); p.Kind() {
|
||||
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
|
||||
var i int64
|
||||
i, err = strconv.ParseInt(string(byt), 10, 64)
|
||||
if err != nil {
|
||||
log.Fatalf("xorm/cache: failed to parse int '%s': %s", string(byt), err)
|
||||
} else {
|
||||
p.SetInt(i)
|
||||
}
|
||||
return
|
||||
|
||||
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
|
||||
var i uint64
|
||||
i, err = strconv.ParseUint(string(byt), 10, 64)
|
||||
if err != nil {
|
||||
log.Fatalf("xorm/cache: failed to parse uint '%s': %s", string(byt), err)
|
||||
} else {
|
||||
p.SetUint(i)
|
||||
}
|
||||
return
|
||||
}
|
||||
}
|
||||
|
||||
func deserialize(byt []byte) (ptr interface{}, err error) {
|
||||
b := bytes.NewBuffer(byt)
|
||||
decoder := gob.NewDecoder(b)
|
||||
|
||||
if ptr, err = interfaceDecode(decoder); err != nil {
|
||||
log.Fatalf("xorm/cache: gob decoding failed: %s", err)
|
||||
log.Fatalf("[xorm/redis_cacher] gob decoding failed: %s", err)
|
||||
return
|
||||
}
|
||||
|
||||
return
|
||||
}
|
||||
|
||||
|
|
@ -259,17 +221,17 @@ func RegisterGobConcreteType(value interface{}) {
|
|||
|
||||
t := reflect.TypeOf(value)
|
||||
|
||||
log.Printf("[xorm/redis_cacher] RegisterGobConcreteType:%v", t)
|
||||
|
||||
switch t.Kind() {
|
||||
case reflect.Ptr:
|
||||
v := reflect.ValueOf(value)
|
||||
i := v.Elem().Interface()
|
||||
gob.Register(i)
|
||||
case reflect.Struct:
|
||||
case reflect.Struct, reflect.Map, reflect.Slice:
|
||||
gob.Register(value)
|
||||
case reflect.Slice:
|
||||
fallthrough
|
||||
case reflect.Map:
|
||||
fallthrough
|
||||
case reflect.String, reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Bool, reflect.Float32, reflect.Float64, reflect.Complex64, reflect.Complex128:
|
||||
// do nothing since already registered known type
|
||||
default:
|
||||
panic(fmt.Errorf("unhandled type: %v", t))
|
||||
}
|
||||
|
|
@ -283,9 +245,11 @@ func interfaceEncode(enc *gob.Encoder, p interface{}) error {
|
|||
// Pass pointer to interface so Encode sees (and hence sends) a value of
|
||||
// interface type. If we passed p directly it would see the concrete type instead.
|
||||
// See the blog post, "The Laws of Reflection" for background.
|
||||
|
||||
log.Printf("[xorm/redis_cacher] interfaceEncode type:%v", reflect.TypeOf(p))
|
||||
err := enc.Encode(&p)
|
||||
if err != nil {
|
||||
log.Fatal("encode:", err)
|
||||
log.Fatal("[xorm/redis_cacher] encode:", err)
|
||||
}
|
||||
return err
|
||||
}
|
||||
|
|
@ -297,7 +261,13 @@ func interfaceDecode(dec *gob.Decoder) (interface{}, error) {
|
|||
var p interface{}
|
||||
err := dec.Decode(&p)
|
||||
if err != nil {
|
||||
log.Fatal("decode:", err)
|
||||
log.Fatal("[xorm/redis_cacher] decode:", err)
|
||||
}
|
||||
log.Printf("[xorm/redis_cacher] interfaceDecode type:%v", reflect.TypeOf(p))
|
||||
|
||||
if reflect.TypeOf(p).Kind() == reflect.Struct {
|
||||
// TODO need to convert p to pointer of struct, however, encountered reflect.ValueOf(p).CanAddr() == false
|
||||
}
|
||||
|
||||
return p, err
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in New Issue