Create & Init Project...

library/cache/memcache/BUILD

@@ -0,0 +1,69 @@
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+    "go_test",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [
+        ":package-srcs",
+        "//library/cache/memcache/test:all-srcs",
+    ],
+    tags = ["automanaged"],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "client.go",
+        "conn.go",
+        "errors.go",
+        "memcache.go",
+        "mock.go",
+        "pool.go",
+        "trace.go",
+        "util.go",
+    ],
+    importpath = "go-common/library/cache/memcache",
+    tags = ["automanaged"],
+    deps = [
+        "//library/container/pool:go_default_library",
+        "//library/net/trace:go_default_library",
+        "//library/stat:go_default_library",
+        "//library/time:go_default_library",
+        "//vendor/github.com/pkg/errors:go_default_library",
+        "@com_github_gogo_protobuf//proto:go_default_library",
+    ],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = [
+        "client_test.go",
+        "conn_test.go",
+        "memcache_test.go",
+        "pool_test.go",
+        "util_test.go",
+    ],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//library/cache/memcache/test:go_default_library",
+        "//library/container/pool:go_default_library",
+        "//library/time:go_default_library",
+        "//vendor/github.com/bouk/monkey:go_default_library",
+        "//vendor/github.com/stretchr/testify/assert:go_default_library",
+        "@com_github_gogo_protobuf//proto:go_default_library",
+    ],
+)

library/cache/memcache/CHANGELOG.md

@@ -0,0 +1,34 @@
+### memcache client
+
+##### Version 1.5.1
+> 1.修复parse reply时如果有err不关闭连接问题  
+
+##### Version 1.5.0
+> 1.支持cache和cache conn的写法
+##### Version 1.4.0
+> 1.add memcache mock conn
+
+##### Version 1.3.2
+> 1.修复判断是否合法key
+
+##### Version 1.3.1
+> 1.修复pool放回连接的bug
+
+##### Version 1.3.0
+> 1.修改memcache pool的实现方式，引用container/pool   
+> 2.pool支持context传入超时以及Get connection WaitTimeout
+
+##### Version 1.2.0
+> 1. 增加pkg errors
+
+##### Version 1.1.2
+> 1. 修复gzip writer默认压缩level为0的bug
+
+##### Version 1.1.1
+> 1. fix populateOne error
+
+##### Version 1.1.0
+> 1. memcache添加largevalue支持
+
+##### Version 1.0.0
+> 1. 修改decode时protobuf bug,补全测试

library/cache/memcache/CONTRIBUTORS.md

@@ -0,0 +1,10 @@
+# Owner
+maojian
+
+# Author 
+maojian
+chenshangqiang
+zhoujixiang
+
+# Reviewer
+maojian

library/cache/memcache/OWNERS

@@ -0,0 +1,13 @@
+# See the OWNERS docs at https://go.k8s.io/owners
+
+approvers:
+- chenshangqiang
+- maojian
+- zhoujixiang
+labels:
+- library
+- library/cache/memcache
+reviewers:
+- chenshangqiang
+- maojian
+- zhoujixiang

library/cache/memcache/README.md

@@ -0,0 +1,32 @@
+# go-common/cache/memcache
+
+##### 项目简介
+> 1. 提供protobuf，gob，json序列化方式，gzip的memcache接口
+
+##### 编译环境
+> 1. 请只用golang v1.7.x以上版本编译执行。
+
+##### 测试
+> 1. 执行当前目录下所有测试文件，测试所有功能
+
+##### 特别说明
+> 1. 使用protobuf需要在pb文件目录下运行business/make.sh脚本生成go文件才能使用
+
+#### 使用方式
+```golang
+// 初始化
+mc := memcache.New(&memcache.Config{})
+// 增加 key
+err = mc.Set(c, &memcache.Item{})
+// 删除key
+err := mc.Delete(c,key)
+// 获得某个key的内容
+err := mc.Get(c,key).Scan(&v)
+// 获取多个key的内容
+replies, err := mc.GetMulti(c, keys)
+for _, key := range replies.Keys() {
+   if err = rows.Scan(key, &v); err != nil {
+       return 
+    }
+}
+```

library/cache/memcache/client.go

@@ -0,0 +1,188 @@
+package memcache
+
+import (
+	"context"
+)
+
+// Memcache memcache client
+type Memcache struct {
+	pool *Pool
+}
+
+// Reply is the result of Get
+type Reply struct {
+	err    error
+	item   *Item
+	conn   Conn
+	closed bool
+}
+
+// Replies is the result of GetMulti
+type Replies struct {
+	err       error
+	items     map[string]*Item
+	usedItems map[string]struct{}
+	conn      Conn
+	closed    bool
+}
+
+// New get a memcache client
+func New(c *Config) *Memcache {
+	return &Memcache{pool: NewPool(c)}
+}
+
+// Close close connection pool
+func (mc *Memcache) Close() error {
+	return mc.pool.Close()
+}
+
+// Conn direct get a connection
+func (mc *Memcache) Conn(c context.Context) Conn {
+	return mc.pool.Get(c)
+}
+
+// Set writes the given item, unconditionally.
+func (mc *Memcache) Set(c context.Context, item *Item) (err error) {
+	conn := mc.pool.Get(c)
+	err = conn.Set(item)
+	conn.Close()
+	return
+}
+
+// Add writes the given item, if no value already exists for its key.
+// ErrNotStored is returned if that condition is not met.
+func (mc *Memcache) Add(c context.Context, item *Item) (err error) {
+	conn := mc.pool.Get(c)
+	err = conn.Add(item)
+	conn.Close()
+	return
+}
+
+// Replace writes the given item, but only if the server *does* already hold data for this key.
+func (mc *Memcache) Replace(c context.Context, item *Item) (err error) {
+	conn := mc.pool.Get(c)
+	err = conn.Replace(item)
+	conn.Close()
+	return
+}
+
+// CompareAndSwap writes the given item that was previously returned by Get
+func (mc *Memcache) CompareAndSwap(c context.Context, item *Item) (err error) {
+	conn := mc.pool.Get(c)
+	err = conn.CompareAndSwap(item)
+	conn.Close()
+	return
+}
+
+// Get sends a command to the server for gets data.
+func (mc *Memcache) Get(c context.Context, key string) *Reply {
+	conn := mc.pool.Get(c)
+	item, err := conn.Get(key)
+	if err != nil {
+		conn.Close()
+	}
+	return &Reply{err: err, item: item, conn: conn}
+}
+
+// Item get raw Item
+func (r *Reply) Item() *Item {
+	return r.item
+}
+
+// Scan converts value, read from the memcache
+func (r *Reply) Scan(v interface{}) (err error) {
+	if r.err != nil {
+		return r.err
+	}
+	err = r.conn.Scan(r.item, v)
+	if !r.closed {
+		r.conn.Close()
+		r.closed = true
+	}
+	return
+}
+
+// GetMulti is a batch version of Get
+func (mc *Memcache) GetMulti(c context.Context, keys []string) (*Replies, error) {
+	conn := mc.pool.Get(c)
+	items, err := conn.GetMulti(keys)
+	rs := &Replies{err: err, items: items, conn: conn, usedItems: make(map[string]struct{}, len(keys))}
+	if err != nil {
+		conn.Close()
+		rs.closed = true
+	}
+	return rs, err
+}
+
+// Close close rows.
+func (rs *Replies) Close() (err error) {
+	if !rs.closed {
+		err = rs.conn.Close()
+		rs.closed = true
+	}
+	return
+}
+
+// Item get Item from rows
+func (rs *Replies) Item(key string) *Item {
+	return rs.items[key]
+}
+
+// Scan converts value, read from key in rows
+func (rs *Replies) Scan(key string, v interface{}) (err error) {
+	if rs.err != nil {
+		return rs.err
+	}
+	item, ok := rs.items[key]
+	if !ok {
+		return ErrNotFound
+	}
+	rs.usedItems[key] = struct{}{}
+	err = rs.conn.Scan(item, v)
+	shouldClose := len(rs.items) == len(rs.usedItems)
+	if shouldClose {
+		rs.Close()
+	}
+	return
+}
+
+// Keys keys of result
+func (rs *Replies) Keys() (keys []string) {
+	keys = make([]string, 0, len(rs.items))
+	for key := range rs.items {
+		keys = append(keys, key)
+	}
+	return
+}
+
+// Touch updates the expiry for the given key.
+func (mc *Memcache) Touch(c context.Context, key string, timeout int32) (err error) {
+	conn := mc.pool.Get(c)
+	err = conn.Touch(key, timeout)
+	conn.Close()
+	return
+}
+
+// Delete deletes the item with the provided key.
+func (mc *Memcache) Delete(c context.Context, key string) (err error) {
+	conn := mc.pool.Get(c)
+	err = conn.Delete(key)
+	conn.Close()
+	return
+}
+
+// Increment atomically increments key by delta.
+func (mc *Memcache) Increment(c context.Context, key string, delta uint64) (newValue uint64, err error) {
+	conn := mc.pool.Get(c)
+	newValue, err = conn.Increment(key, delta)
+	conn.Close()
+	return
+}
+
+// Decrement atomically decrements key by delta.
+func (mc *Memcache) Decrement(c context.Context, key string, delta uint64) (newValue uint64, err error) {
+	conn := mc.pool.Get(c)
+	newValue, err = conn.Decrement(key, delta)
+	conn.Close()
+	return
+}

library/cache/memcache/client_test.go

@@ -0,0 +1,302 @@
+package memcache
+
+import (
+	"context"
+	"fmt"
+	"reflect"
+	"testing"
+	"time"
+)
+
+var testClient *Memcache
+
+func Test_client_Set(t *testing.T) {
+	type args struct {
+		c    context.Context
+		item *Item
+	}
+	tests := []struct {
+		name    string
+		args    args
+		wantErr bool
+	}{
+		{name: "set value", args: args{c: context.Background(), item: &Item{Key: "Test_client_Set", Value: []byte("abc")}}, wantErr: false},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if err := testClient.Set(tt.args.c, tt.args.item); (err != nil) != tt.wantErr {
+				t.Errorf("client.Set() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}
+
+func Test_client_Add(t *testing.T) {
+	type args struct {
+		c    context.Context
+		item *Item
+	}
+	key := fmt.Sprintf("Test_client_Add_%d", time.Now().Unix())
+	tests := []struct {
+		name    string
+		args    args
+		wantErr bool
+	}{
+		{name: "add not exist value", args: args{c: context.Background(), item: &Item{Key: key, Value: []byte("abc")}}, wantErr: false},
+		{name: "add exist value", args: args{c: context.Background(), item: &Item{Key: key, Value: []byte("abc")}}, wantErr: true},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if err := testClient.Add(tt.args.c, tt.args.item); (err != nil) != tt.wantErr {
+				t.Errorf("client.Add() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}
+
+func Test_client_Replace(t *testing.T) {
+	key := fmt.Sprintf("Test_client_Replace_%d", time.Now().Unix())
+	ekey := "Test_client_Replace_exist"
+	testClient.Set(context.Background(), &Item{Key: ekey, Value: []byte("ok")})
+	type args struct {
+		c    context.Context
+		item *Item
+	}
+	tests := []struct {
+		name    string
+		args    args
+		wantErr bool
+	}{
+		{name: "not exist value", args: args{c: context.Background(), item: &Item{Key: key, Value: []byte("abc")}}, wantErr: true},
+		{name: "exist value", args: args{c: context.Background(), item: &Item{Key: ekey, Value: []byte("abc")}}, wantErr: false},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if err := testClient.Replace(tt.args.c, tt.args.item); (err != nil) != tt.wantErr {
+				t.Errorf("client.Replace() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}
+
+func Test_client_CompareAndSwap(t *testing.T) {
+	key := fmt.Sprintf("Test_client_CompareAndSwap_%d", time.Now().Unix())
+	ekey := "Test_client_CompareAndSwap_k"
+	testClient.Set(context.Background(), &Item{Key: ekey, Value: []byte("old")})
+	cas := testClient.Get(context.Background(), ekey).Item().cas
+	type args struct {
+		c    context.Context
+		item *Item
+	}
+	tests := []struct {
+		name    string
+		args    args
+		wantErr bool
+	}{
+		{name: "not exist value", args: args{c: context.Background(), item: &Item{Key: key, Value: []byte("abc")}}, wantErr: true},
+		{name: "exist value", args: args{c: context.Background(), item: &Item{Key: ekey, cas: cas, Value: []byte("abc")}}, wantErr: false},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if err := testClient.CompareAndSwap(tt.args.c, tt.args.item); (err != nil) != tt.wantErr {
+				t.Errorf("client.CompareAndSwap() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}
+
+func Test_client_Get(t *testing.T) {
+	key := fmt.Sprintf("Test_client_Get_%d", time.Now().Unix())
+	ekey := "Test_client_Get_k"
+	testClient.Set(context.Background(), &Item{Key: ekey, Value: []byte("old")})
+	type args struct {
+		c   context.Context
+		key string
+	}
+	tests := []struct {
+		name    string
+		args    args
+		want    string
+		wantErr bool
+	}{
+		{name: "not exist value", args: args{c: context.Background(), key: key}, wantErr: true},
+		{name: "exist value", args: args{c: context.Background(), key: ekey}, wantErr: false, want: "old"},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			var res string
+			if err := testClient.Get(tt.args.c, tt.args.key).Scan(&res); (err != nil) != tt.wantErr || res != tt.want {
+				t.Errorf("client.Get() = %v, want %v, got err: %v, want err: %v", err, tt.want, err, tt.wantErr)
+			}
+		})
+	}
+}
+
+func Test_client_Touch(t *testing.T) {
+	key := fmt.Sprintf("Test_client_Touch_%d", time.Now().Unix())
+	ekey := "Test_client_Touch_k"
+	testClient.Set(context.Background(), &Item{Key: ekey, Value: []byte("old")})
+	type args struct {
+		c       context.Context
+		key     string
+		timeout int32
+	}
+	tests := []struct {
+		name    string
+		args    args
+		wantErr bool
+	}{
+		{name: "not exist value", args: args{c: context.Background(), key: key, timeout: 100000}, wantErr: true},
+		{name: "exist value", args: args{c: context.Background(), key: ekey, timeout: 100000}, wantErr: false},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if err := testClient.Touch(tt.args.c, tt.args.key, tt.args.timeout); (err != nil) != tt.wantErr {
+				t.Errorf("client.Touch() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}
+
+func Test_client_Delete(t *testing.T) {
+	key := fmt.Sprintf("Test_client_Delete_%d", time.Now().Unix())
+	ekey := "Test_client_Delete_k"
+	testClient.Set(context.Background(), &Item{Key: ekey, Value: []byte("old")})
+	type args struct {
+		c   context.Context
+		key string
+	}
+	tests := []struct {
+		name    string
+		args    args
+		wantErr bool
+	}{
+		{name: "not exist value", args: args{c: context.Background(), key: key}, wantErr: true},
+		{name: "exist value", args: args{c: context.Background(), key: ekey}, wantErr: false},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if err := testClient.Delete(tt.args.c, tt.args.key); (err != nil) != tt.wantErr {
+				t.Errorf("client.Delete() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}
+
+func Test_client_Increment(t *testing.T) {
+	key := fmt.Sprintf("Test_client_Increment_%d", time.Now().Unix())
+	ekey := "Test_client_Increment_k"
+	testClient.Set(context.Background(), &Item{Key: ekey, Value: []byte("1")})
+	type args struct {
+		c     context.Context
+		key   string
+		delta uint64
+	}
+	tests := []struct {
+		name         string
+		args         args
+		wantNewValue uint64
+		wantErr      bool
+	}{
+		{name: "not exist value", args: args{c: context.Background(), key: key, delta: 10}, wantErr: true},
+		{name: "exist value", args: args{c: context.Background(), key: ekey, delta: 10}, wantErr: false, wantNewValue: 11},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			gotNewValue, err := testClient.Increment(tt.args.c, tt.args.key, tt.args.delta)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("client.Increment() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if gotNewValue != tt.wantNewValue {
+				t.Errorf("client.Increment() = %v, want %v", gotNewValue, tt.wantNewValue)
+			}
+		})
+	}
+}
+
+func Test_client_Decrement(t *testing.T) {
+	key := fmt.Sprintf("Test_client_Decrement_%d", time.Now().Unix())
+	ekey := "Test_client_Decrement_k"
+	testClient.Set(context.Background(), &Item{Key: ekey, Value: []byte("100")})
+	type args struct {
+		c     context.Context
+		key   string
+		delta uint64
+	}
+	tests := []struct {
+		name         string
+		args         args
+		wantNewValue uint64
+		wantErr      bool
+	}{
+		{name: "not exist value", args: args{c: context.Background(), key: key, delta: 10}, wantErr: true},
+		{name: "exist value", args: args{c: context.Background(), key: ekey, delta: 10}, wantErr: false, wantNewValue: 90},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			gotNewValue, err := testClient.Decrement(tt.args.c, tt.args.key, tt.args.delta)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("client.Decrement() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if gotNewValue != tt.wantNewValue {
+				t.Errorf("client.Decrement() = %v, want %v", gotNewValue, tt.wantNewValue)
+			}
+		})
+	}
+}
+
+func Test_client_GetMulti(t *testing.T) {
+	key := fmt.Sprintf("Test_client_GetMulti_%d", time.Now().Unix())
+	ekey1 := "Test_client_GetMulti_k1"
+	ekey2 := "Test_client_GetMulti_k2"
+	testClient.Set(context.Background(), &Item{Key: ekey1, Value: []byte("1")})
+	testClient.Set(context.Background(), &Item{Key: ekey2, Value: []byte("2")})
+	keys := []string{key, ekey1, ekey2}
+	rows, err := testClient.GetMulti(context.Background(), keys)
+	if err != nil {
+		t.Errorf("client.GetMulti() error = %v, wantErr %v", err, nil)
+	}
+	tests := []struct {
+		key          string
+		wantNewValue string
+		wantErr      bool
+		nilItem      bool
+	}{
+		{key: key, wantErr: true, nilItem: true},
+		{key: ekey1, wantErr: false, wantNewValue: "1", nilItem: false},
+		{key: ekey2, wantErr: false, wantNewValue: "2", nilItem: false},
+	}
+	if reflect.DeepEqual(keys, rows.Keys()) {
+		t.Errorf("got %v, expect: %v", rows.Keys(), keys)
+	}
+	for _, tt := range tests {
+		t.Run(tt.key, func(t *testing.T) {
+			var gotNewValue string
+			err = rows.Scan(tt.key, &gotNewValue)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("rows.Scan() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if gotNewValue != tt.wantNewValue {
+				t.Errorf("rows.Value() = %v, want %v", gotNewValue, tt.wantNewValue)
+			}
+			if (rows.Item(tt.key) == nil) != tt.nilItem {
+				t.Errorf("rows.Item() = %v, want %v", rows.Item(tt.key) == nil, tt.nilItem)
+			}
+		})
+	}
+	err = rows.Close()
+	if err != nil {
+		t.Errorf("client.Replies.Close() error = %v, wantErr %v", err, nil)
+	}
+}
+
+func Test_client_Conn(t *testing.T) {
+	conn := testClient.Conn(context.Background())
+	defer conn.Close()
+	if conn == nil {
+		t.Errorf("expect get conn, get nil")
+	}
+}

library/cache/memcache/conn.go

@@ -0,0 +1,685 @@
+package memcache
+
+import (
+	"bufio"
+	"bytes"
+	"compress/gzip"
+	"context"
+	"encoding/gob"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/gogo/protobuf/proto"
+	pkgerr "github.com/pkg/errors"
+)
+
+var (
+	crlf                   = []byte("\r\n")
+	spaceStr               = string(" ")
+	replyOK                = []byte("OK\r\n")
+	replyStored            = []byte("STORED\r\n")
+	replyNotStored         = []byte("NOT_STORED\r\n")
+	replyExists            = []byte("EXISTS\r\n")
+	replyNotFound          = []byte("NOT_FOUND\r\n")
+	replyDeleted           = []byte("DELETED\r\n")
+	replyEnd               = []byte("END\r\n")
+	replyTouched           = []byte("TOUCHED\r\n")
+	replyValueStr          = "VALUE"
+	replyClientErrorPrefix = []byte("CLIENT_ERROR ")
+	replyServerErrorPrefix = []byte("SERVER_ERROR ")
+)
+
+const (
+	_encodeBuf = 4096 // 4kb
+	// 1024*1024 - 1, set error???
+	_largeValue = 1000 * 1000 // 1MB
+)
+
+type reader struct {
+	io.Reader
+}
+
+func (r *reader) Reset(rd io.Reader) {
+	r.Reader = rd
+}
+
+// conn is the low-level implementation of Conn
+type conn struct {
+	// Shared
+	mu   sync.Mutex
+	err  error
+	conn net.Conn
+	// Read & Write
+	readTimeout  time.Duration
+	writeTimeout time.Duration
+	rw           *bufio.ReadWriter
+	// Item Reader
+	ir bytes.Reader
+	// Compress
+	gr gzip.Reader
+	gw *gzip.Writer
+	cb bytes.Buffer
+	// Encoding
+	edb bytes.Buffer
+	// json
+	jr reader
+	jd *json.Decoder
+	je *json.Encoder
+	// protobuffer
+	ped *proto.Buffer
+}
+
+// DialOption specifies an option for dialing a Memcache server.
+type DialOption struct {
+	f func(*dialOptions)
+}
+
+type dialOptions struct {
+	readTimeout  time.Duration
+	writeTimeout time.Duration
+	dial         func(network, addr string) (net.Conn, error)
+}
+
+// DialReadTimeout specifies the timeout for reading a single command reply.
+func DialReadTimeout(d time.Duration) DialOption {
+	return DialOption{func(do *dialOptions) {
+		do.readTimeout = d
+	}}
+}
+
+// DialWriteTimeout specifies the timeout for writing a single command.
+func DialWriteTimeout(d time.Duration) DialOption {
+	return DialOption{func(do *dialOptions) {
+		do.writeTimeout = d
+	}}
+}
+
+// DialConnectTimeout specifies the timeout for connecting to the Memcache server.
+func DialConnectTimeout(d time.Duration) DialOption {
+	return DialOption{func(do *dialOptions) {
+		dialer := net.Dialer{Timeout: d}
+		do.dial = dialer.Dial
+	}}
+}
+
+// DialNetDial specifies a custom dial function for creating TCP
+// connections. If this option is left out, then net.Dial is
+// used. DialNetDial overrides DialConnectTimeout.
+func DialNetDial(dial func(network, addr string) (net.Conn, error)) DialOption {
+	return DialOption{func(do *dialOptions) {
+		do.dial = dial
+	}}
+}
+
+// Dial connects to the Memcache server at the given network and
+// address using the specified options.
+func Dial(network, address string, options ...DialOption) (Conn, error) {
+	do := dialOptions{
+		dial: net.Dial,
+	}
+	for _, option := range options {
+		option.f(&do)
+	}
+	netConn, err := do.dial(network, address)
+	if err != nil {
+		return nil, pkgerr.WithStack(err)
+	}
+	return NewConn(netConn, do.readTimeout, do.writeTimeout), nil
+}
+
+// NewConn returns a new memcache connection for the given net connection.
+func NewConn(netConn net.Conn, readTimeout, writeTimeout time.Duration) Conn {
+	if writeTimeout <= 0 || readTimeout <= 0 {
+		panic("must config memcache timeout")
+	}
+	c := &conn{
+		conn: netConn,
+		rw: bufio.NewReadWriter(bufio.NewReader(netConn),
+			bufio.NewWriter(netConn)),
+		readTimeout:  readTimeout,
+		writeTimeout: writeTimeout,
+	}
+	c.jd = json.NewDecoder(&c.jr)
+	c.je = json.NewEncoder(&c.edb)
+	c.gw = gzip.NewWriter(&c.cb)
+	c.edb.Grow(_encodeBuf)
+	// NOTE reuse bytes.Buffer internal buf
+	// DON'T concurrency call Scan
+	c.ped = proto.NewBuffer(c.edb.Bytes())
+	return c
+}
+
+func (c *conn) Close() error {
+	c.mu.Lock()
+	err := c.err
+	if c.err == nil {
+		c.err = pkgerr.New("memcache: closed")
+		err = c.conn.Close()
+	}
+	c.mu.Unlock()
+	return err
+}
+
+func (c *conn) fatal(err error) error {
+	c.mu.Lock()
+	if c.err == nil {
+		c.err = pkgerr.WithStack(err)
+		// Close connection to force errors on subsequent calls and to unblock
+		// other reader or writer.
+		c.conn.Close()
+	}
+	c.mu.Unlock()
+	return c.err
+}
+
+func (c *conn) Err() error {
+	c.mu.Lock()
+	err := c.err
+	c.mu.Unlock()
+	return err
+}
+
+func (c *conn) Add(item *Item) error {
+	return c.populate("add", item)
+}
+
+func (c *conn) Set(item *Item) error {
+	return c.populate("set", item)
+}
+
+func (c *conn) Replace(item *Item) error {
+	return c.populate("replace", item)
+}
+
+func (c *conn) CompareAndSwap(item *Item) error {
+	return c.populate("cas", item)
+}
+
+func (c *conn) populate(cmd string, item *Item) (err error) {
+	if !legalKey(item.Key) {
+		return pkgerr.WithStack(ErrMalformedKey)
+	}
+	var res []byte
+	if res, err = c.encode(item); err != nil {
+		return
+	}
+	l := len(res)
+	count := l/(_largeValue) + 1
+	if count == 1 {
+		item.Value = res
+		return c.populateOne(cmd, item)
+	}
+	nItem := &Item{
+		Key:        item.Key,
+		Value:      []byte(strconv.Itoa(l)),
+		Expiration: item.Expiration,
+		Flags:      item.Flags | flagLargeValue,
+	}
+	err = c.populateOne(cmd, nItem)
+	if err != nil {
+		return
+	}
+	k := item.Key
+	nItem.Flags = item.Flags
+	for i := 1; i <= count; i++ {
+		if i == count {
+			nItem.Value = res[_largeValue*(count-1):]
+		} else {
+			nItem.Value = res[_largeValue*(i-1) : _largeValue*i]
+		}
+		nItem.Key = fmt.Sprintf("%s%d", k, i)
+		if err = c.populateOne(cmd, nItem); err != nil {
+			return
+		}
+	}
+	return
+}
+
+func (c *conn) populateOne(cmd string, item *Item) (err error) {
+	if c.writeTimeout != 0 {
+		c.conn.SetWriteDeadline(time.Now().Add(c.writeTimeout))
+	}
+
+	// <command name> <key> <flags> <exptime> <bytes> [noreply]\r\n
+	if cmd == "cas" {
+		_, err = fmt.Fprintf(c.rw, "%s %s %d %d %d %d\r\n",
+			cmd, item.Key, item.Flags, item.Expiration, len(item.Value), item.cas)
+	} else {
+		_, err = fmt.Fprintf(c.rw, "%s %s %d %d %d\r\n",
+			cmd, item.Key, item.Flags, item.Expiration, len(item.Value))
+	}
+	if err != nil {
+		return c.fatal(err)
+	}
+	c.rw.Write(item.Value)
+	c.rw.Write(crlf)
+	if err = c.rw.Flush(); err != nil {
+		return c.fatal(err)
+	}
+	if c.readTimeout != 0 {
+		c.conn.SetReadDeadline(time.Now().Add(c.readTimeout))
+	}
+	line, err := c.rw.ReadSlice('\n')
+	if err != nil {
+		return c.fatal(err)
+	}
+	switch {
+	case bytes.Equal(line, replyStored):
+		return nil
+	case bytes.Equal(line, replyNotStored):
+		return ErrNotStored
+	case bytes.Equal(line, replyExists):
+		return ErrCASConflict
+	case bytes.Equal(line, replyNotFound):
+		return ErrNotFound
+	}
+	return pkgerr.WithStack(protocolError(string(line)))
+}
+
+func (c *conn) Get(key string) (r *Item, err error) {
+	if !legalKey(key) {
+		return nil, pkgerr.WithStack(ErrMalformedKey)
+	}
+	if c.writeTimeout != 0 {
+		c.conn.SetWriteDeadline(time.Now().Add(c.writeTimeout))
+	}
+	if _, err = fmt.Fprintf(c.rw, "gets %s\r\n", key); err != nil {
+		return nil, c.fatal(err)
+	}
+	if err = c.rw.Flush(); err != nil {
+		return nil, c.fatal(err)
+	}
+	if err = c.parseGetReply(func(it *Item) {
+		r = it
+	}); err != nil {
+		return
+	}
+	if r == nil {
+		err = ErrNotFound
+		return
+	}
+	if r.Flags&flagLargeValue != flagLargeValue {
+		return
+	}
+	if r, err = c.getLargeValue(r); err != nil {
+		return
+	}
+	return
+}
+
+func (c *conn) GetMulti(keys []string) (res map[string]*Item, err error) {
+	for _, key := range keys {
+		if !legalKey(key) {
+			return nil, pkgerr.WithStack(ErrMalformedKey)
+		}
+	}
+	if c.writeTimeout != 0 {
+		c.conn.SetWriteDeadline(time.Now().Add(c.writeTimeout))
+	}
+	if _, err = fmt.Fprintf(c.rw, "gets %s\r\n", strings.Join(keys, " ")); err != nil {
+		return nil, c.fatal(err)
+	}
+	if err = c.rw.Flush(); err != nil {
+		return nil, c.fatal(err)
+	}
+	res = make(map[string]*Item, len(keys))
+	if err = c.parseGetReply(func(it *Item) {
+		res[it.Key] = it
+	}); err != nil {
+		return
+	}
+	for k, v := range res {
+		if v.Flags&flagLargeValue != flagLargeValue {
+			continue
+		}
+		r, err := c.getLargeValue(v)
+		if err != nil {
+			return res, err
+		}
+		res[k] = r
+	}
+	return
+}
+
+func (c *conn) getMulti(keys []string) (res map[string]*Item, err error) {
+	for _, key := range keys {
+		if !legalKey(key) {
+			return nil, pkgerr.WithStack(ErrMalformedKey)
+		}
+	}
+	if c.writeTimeout != 0 {
+		c.conn.SetWriteDeadline(time.Now().Add(c.writeTimeout))
+	}
+	if _, err = fmt.Fprintf(c.rw, "gets %s\r\n", strings.Join(keys, " ")); err != nil {
+		return nil, c.fatal(err)
+	}
+	if err = c.rw.Flush(); err != nil {
+		return nil, c.fatal(err)
+	}
+	res = make(map[string]*Item, len(keys))
+	err = c.parseGetReply(func(it *Item) {
+		res[it.Key] = it
+	})
+	return
+}
+
+func (c *conn) getLargeValue(it *Item) (r *Item, err error) {
+	l, err := strconv.Atoi(string(it.Value))
+	if err != nil {
+		return
+	}
+	count := l/_largeValue + 1
+	keys := make([]string, 0, count)
+	for i := 1; i <= count; i++ {
+		keys = append(keys, fmt.Sprintf("%s%d", it.Key, i))
+	}
+	items, err := c.getMulti(keys)
+	if err != nil {
+		return
+	}
+	if len(items) < count {
+		err = ErrNotFound
+		return
+	}
+	v := make([]byte, 0, l)
+	for _, k := range keys {
+		if items[k] == nil || items[k].Value == nil {
+			err = ErrNotFound
+			return
+		}
+		v = append(v, items[k].Value...)
+	}
+	it.Value = v
+	it.Flags = it.Flags ^ flagLargeValue
+	r = it
+	return
+}
+
+func (c *conn) parseGetReply(f func(*Item)) error {
+	if c.readTimeout != 0 {
+		c.conn.SetReadDeadline(time.Now().Add(c.readTimeout))
+	}
+	for {
+		line, err := c.rw.ReadSlice('\n')
+		if err != nil {
+			return c.fatal(err)
+		}
+		if bytes.Equal(line, replyEnd) {
+			return nil
+		}
+		if bytes.HasPrefix(line, replyServerErrorPrefix) {
+			errMsg := line[len(replyServerErrorPrefix):]
+			return c.fatal(protocolError(errMsg))
+		}
+		it := new(Item)
+		size, err := scanGetReply(line, it)
+		if err != nil {
+			return c.fatal(err)
+		}
+		it.Value = make([]byte, size+2)
+		if _, err = io.ReadFull(c.rw, it.Value); err != nil {
+			return c.fatal(err)
+		}
+		if !bytes.HasSuffix(it.Value, crlf) {
+			return c.fatal(protocolError("corrupt get reply, no except CRLF"))
+		}
+		it.Value = it.Value[:size]
+		f(it)
+	}
+}
+
+func scanGetReply(line []byte, item *Item) (size int, err error) {
+	if !bytes.HasSuffix(line, crlf) {
+		return 0, protocolError("corrupt get reply, no except CRLF")
+	}
+	// VALUE <key> <flags> <bytes> [<cas unique>]
+	chunks := strings.Split(string(line[:len(line)-2]), spaceStr)
+	if len(chunks) < 4 {
+		return 0, protocolError("corrupt get reply")
+	}
+	if chunks[0] != replyValueStr {
+		return 0, protocolError("corrupt get reply, no except VALUE")
+	}
+	item.Key = chunks[1]
+	flags64, err := strconv.ParseUint(chunks[2], 10, 32)
+	if err != nil {
+		return 0, err
+	}
+	item.Flags = uint32(flags64)
+	if size, err = strconv.Atoi(chunks[3]); err != nil {
+		return
+	}
+	if len(chunks) > 4 {
+		item.cas, err = strconv.ParseUint(chunks[4], 10, 64)
+	}
+	return
+}
+
+func (c *conn) Touch(key string, expire int32) (err error) {
+	if !legalKey(key) {
+		return pkgerr.WithStack(ErrMalformedKey)
+	}
+	line, err := c.writeReadLine("touch %s %d\r\n", key, expire)
+	if err != nil {
+		return err
+	}
+	switch {
+	case bytes.Equal(line, replyTouched):
+		return nil
+	case bytes.Equal(line, replyNotFound):
+		return ErrNotFound
+	default:
+		return pkgerr.WithStack(protocolError(string(line)))
+	}
+}
+
+func (c *conn) Increment(key string, delta uint64) (uint64, error) {
+	return c.incrDecr("incr", key, delta)
+}
+
+func (c *conn) Decrement(key string, delta uint64) (newValue uint64, err error) {
+	return c.incrDecr("decr", key, delta)
+}
+
+func (c *conn) incrDecr(cmd, key string, delta uint64) (uint64, error) {
+	if !legalKey(key) {
+		return 0, pkgerr.WithStack(ErrMalformedKey)
+	}
+	line, err := c.writeReadLine("%s %s %d\r\n", cmd, key, delta)
+	if err != nil {
+		return 0, err
+	}
+	switch {
+	case bytes.Equal(line, replyNotFound):
+		return 0, ErrNotFound
+	case bytes.HasPrefix(line, replyClientErrorPrefix):
+		errMsg := line[len(replyClientErrorPrefix):]
+		return 0, pkgerr.WithStack(protocolError(errMsg))
+	}
+	val, err := strconv.ParseUint(string(line[:len(line)-2]), 10, 64)
+	if err != nil {
+		return 0, err
+	}
+	return val, nil
+}
+
+func (c *conn) Delete(key string) (err error) {
+	if !legalKey(key) {
+		return pkgerr.WithStack(ErrMalformedKey)
+	}
+	line, err := c.writeReadLine("delete %s\r\n", key)
+	if err != nil {
+		return err
+	}
+	switch {
+	case bytes.Equal(line, replyOK):
+		return nil
+	case bytes.Equal(line, replyDeleted):
+		return nil
+	case bytes.Equal(line, replyNotStored):
+		return ErrNotStored
+	case bytes.Equal(line, replyExists):
+		return ErrCASConflict
+	case bytes.Equal(line, replyNotFound):
+		return ErrNotFound
+	}
+	return pkgerr.WithStack(protocolError(string(line)))
+}
+
+func (c *conn) writeReadLine(format string, args ...interface{}) ([]byte, error) {
+	if c.writeTimeout != 0 {
+		c.conn.SetWriteDeadline(time.Now().Add(c.writeTimeout))
+	}
+	_, err := fmt.Fprintf(c.rw, format, args...)
+	if err != nil {
+		return nil, c.fatal(pkgerr.WithStack(err))
+	}
+	if err = c.rw.Flush(); err != nil {
+		return nil, c.fatal(pkgerr.WithStack(err))
+	}
+	if c.readTimeout != 0 {
+		c.conn.SetReadDeadline(time.Now().Add(c.readTimeout))
+	}
+	line, err := c.rw.ReadSlice('\n')
+	if err != nil {
+		return line, c.fatal(pkgerr.WithStack(err))
+	}
+	return line, nil
+}
+
+func (c *conn) Scan(item *Item, v interface{}) (err error) {
+	c.ir.Reset(item.Value)
+	if item.Flags&FlagGzip == FlagGzip {
+		if err = c.gr.Reset(&c.ir); err != nil {
+			return
+		}
+		if err = c.decode(&c.gr, item, v); err != nil {
+			err = pkgerr.WithStack(err)
+			return
+		}
+		err = c.gr.Close()
+	} else {
+		err = c.decode(&c.ir, item, v)
+	}
+	err = pkgerr.WithStack(err)
+	return
+}
+
+func (c *conn) WithContext(ctx context.Context) Conn {
+	// FIXME: implement WithContext
+	return c
+}
+
+func (c *conn) encode(item *Item) (data []byte, err error) {
+	if (item.Flags | _flagEncoding) == _flagEncoding {
+		if item.Value == nil {
+			return nil, ErrItem
+		}
+	} else if item.Object == nil {
+		return nil, ErrItem
+	}
+	// encoding
+	switch {
+	case item.Flags&FlagGOB == FlagGOB:
+		c.edb.Reset()
+		if err = gob.NewEncoder(&c.edb).Encode(item.Object); err != nil {
+			return
+		}
+		data = c.edb.Bytes()
+	case item.Flags&FlagProtobuf == FlagProtobuf:
+		c.edb.Reset()
+		c.ped.SetBuf(c.edb.Bytes())
+		pb, ok := item.Object.(proto.Message)
+		if !ok {
+			err = ErrItemObject
+			return
+		}
+		if err = c.ped.Marshal(pb); err != nil {
+			return
+		}
+		data = c.ped.Bytes()
+	case item.Flags&FlagJSON == FlagJSON:
+		c.edb.Reset()
+		if err = c.je.Encode(item.Object); err != nil {
+			return
+		}
+		data = c.edb.Bytes()
+	default:
+		data = item.Value
+	}
+	// compress
+	if item.Flags&FlagGzip == FlagGzip {
+		c.cb.Reset()
+		c.gw.Reset(&c.cb)
+		if _, err = c.gw.Write(data); err != nil {
+			return
+		}
+		if err = c.gw.Close(); err != nil {
+			return
+		}
+		data = c.cb.Bytes()
+	}
+	if len(data) > 8000000 {
+		err = ErrValueSize
+	}
+	return
+}
+
+func (c *conn) decode(rd io.Reader, item *Item, v interface{}) (err error) {
+	var data []byte
+	switch {
+	case item.Flags&FlagGOB == FlagGOB:
+		err = gob.NewDecoder(rd).Decode(v)
+	case item.Flags&FlagJSON == FlagJSON:
+		c.jr.Reset(rd)
+		err = c.jd.Decode(v)
+	default:
+		data = item.Value
+		if item.Flags&FlagGzip == FlagGzip {
+			c.edb.Reset()
+			if _, err = io.Copy(&c.edb, rd); err != nil {
+				return
+			}
+			data = c.edb.Bytes()
+		}
+		if item.Flags&FlagProtobuf == FlagProtobuf {
+			m, ok := v.(proto.Message)
+			if !ok {
+				err = ErrItemObject
+				return
+			}
+			c.ped.SetBuf(data)
+			err = c.ped.Unmarshal(m)
+		} else {
+			switch v.(type) {
+			case *[]byte:
+				d := v.(*[]byte)
+				*d = data
+			case *string:
+				d := v.(*string)
+				*d = string(data)
+			case interface{}:
+				err = json.Unmarshal(data, v)
+			}
+		}
+	}
+	return
+}
+
+func legalKey(key string) bool {
+	if len(key) > 250 || len(key) == 0 {
+		return false
+	}
+	for i := 0; i < len(key); i++ {
+		if key[i] <= ' ' || key[i] == 0x7f {
+			return false
+		}
+	}
+	return true
+}

library/cache/memcache/conn_test.go

@@ -0,0 +1,524 @@
+package memcache
+
+import (
+	"bytes"
+	"encoding/json"
+	"errors"
+	test "go-common/library/cache/memcache/test"
+	"testing"
+	"time"
+
+	"github.com/bouk/monkey"
+	"github.com/gogo/protobuf/proto"
+)
+
+var s = []string{"test", "test1"}
+var c Conn
+
+var item = &Item{
+	Key:        "test",
+	Value:      []byte("test"),
+	Flags:      FlagRAW,
+	Expiration: 60,
+	cas:        0,
+}
+
+var item2 = &Item{
+	Key:        "test1",
+	Value:      []byte("test"),
+	Flags:      0,
+	Expiration: 1000,
+	cas:        0,
+}
+
+var item3 = &Item{
+	Key:        "test2",
+	Value:      []byte("0"),
+	Flags:      0,
+	Expiration: 60,
+	cas:        0,
+}
+
+type TestItem struct {
+	Name string
+	Age  int
+}
+
+func (t *TestItem) Compare(nt *TestItem) bool {
+	return t.Name == nt.Name && t.Age == nt.Age
+}
+
+func prepareEnv(t *testing.T) {
+	if c != nil {
+		return
+	}
+	var err error
+	cnop := DialConnectTimeout(time.Duration(2 * time.Second))
+	rdop := DialReadTimeout(time.Duration(2 * time.Second))
+	wrop := DialWriteTimeout(time.Duration(2 * time.Second))
+	c, err = Dial("tcp", testMemcacheAddr, cnop, rdop, wrop)
+	if err != nil {
+		t.Errorf("Dial() error(%v)", err)
+		t.FailNow()
+	}
+	c.Delete("test")
+	c.Delete("test1")
+	c.Delete("test2")
+}
+
+func TestRaw(t *testing.T) {
+	prepareEnv(t)
+	if err := c.Set(item); err != nil {
+		t.Errorf("conn.Store() error(%v)", err)
+	}
+}
+
+func TestAdd(t *testing.T) {
+	var (
+		key  = "test_add"
+		item = &Item{
+			Key:        key,
+			Value:      []byte("0"),
+			Flags:      0,
+			Expiration: 60,
+			cas:        0,
+		}
+	)
+	prepareEnv(t)
+	c.Delete(key)
+	if err := c.Add(item); err != nil {
+		t.Errorf("c.Add() error(%v)", err)
+	}
+	if err := c.Add(item); err != ErrNotStored {
+		t.Errorf("c.Add() error(%v)", err)
+	}
+}
+
+func TestSetErr(t *testing.T) {
+	prepareEnv(t)
+	//set
+	st := &TestItem{Name: "jsongzip", Age: 10}
+	itemx := &Item{Key: "jsongzip", Object: st}
+	if err := c.Set(itemx); err != ErrItem {
+		t.Errorf("conn.Set() error(%v)", err)
+	}
+}
+
+func TestSetErr2(t *testing.T) {
+	prepareEnv(t)
+	//set
+	itemx := &Item{Key: "jsongzip", Flags: FlagJSON | FlagGzip}
+	if err := c.Set(itemx); err != ErrItem {
+		t.Errorf("conn.Set() error(%v)", err)
+	}
+}
+
+func TestSetErr3(t *testing.T) {
+	prepareEnv(t)
+	//set
+	itemx := &Item{Key: "jsongzip", Value: []byte("test"), Flags: FlagJSON}
+	if err := c.Set(itemx); err != ErrItem {
+		t.Errorf("conn.Set() error(%v)", err)
+	}
+}
+
+func TestJSONGzip(t *testing.T) {
+	prepareEnv(t)
+	//set
+	st := &TestItem{Name: "jsongzip", Age: 10}
+	itemx := &Item{Key: "jsongzip", Object: st, Flags: FlagJSON | FlagGzip}
+	if err := c.Set(itemx); err != nil {
+		t.Errorf("conn.Set() error(%v)", err)
+	}
+	if r, err := c.Get("jsongzip"); err != nil {
+		t.Errorf("conn.Get() error(%v)", err)
+	} else {
+		var nst TestItem
+		scanAndCompare(t, r, st, &nst)
+	}
+}
+
+func TestJSON(t *testing.T) {
+	prepareEnv(t)
+	st := &TestItem{Name: "json", Age: 10}
+	itemx := &Item{Key: "json", Object: st, Flags: FlagJSON}
+	if err := c.Set(itemx); err != nil {
+		t.Errorf("conn.Set() error(%v)", err)
+	}
+	if r, err := c.Get("json"); err != nil {
+		t.Errorf("conn.Get() error(%v)", err)
+	} else {
+		var nst TestItem
+		scanAndCompare(t, r, st, &nst)
+	}
+}
+
+func BenchmarkJSON(b *testing.B) {
+	st := &TestItem{Name: "json", Age: 10}
+	itemx := &Item{Key: "json", Object: st, Flags: FlagJSON}
+	var (
+		eb  bytes.Buffer
+		je  *json.Encoder
+		ir  bytes.Reader
+		jd  *json.Decoder
+		jr  reader
+		nst test.TestItem
+	)
+	jd = json.NewDecoder(&jr)
+	je = json.NewEncoder(&eb)
+	eb.Grow(_encodeBuf)
+	// NOTE reuse bytes.Buffer internal buf
+	// DON'T concurrency call Scan
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		eb.Reset()
+		if err := je.Encode(itemx.Object); err != nil {
+			return
+		}
+		data := eb.Bytes()
+		ir.Reset(data)
+		jr.Reset(&ir)
+		jd.Decode(&nst)
+	}
+}
+
+func BenchmarkProtobuf(b *testing.B) {
+	st := &test.TestItem{Name: "protobuf", Age: 10}
+	itemx := &Item{Key: "protobuf", Object: st, Flags: FlagJSON}
+	var (
+		eb  bytes.Buffer
+		nst test.TestItem
+		ped *proto.Buffer
+	)
+	ped = proto.NewBuffer(eb.Bytes())
+	eb.Grow(_encodeBuf)
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		ped.Reset()
+		pb, ok := itemx.Object.(proto.Message)
+		if !ok {
+			return
+		}
+		if err := ped.Marshal(pb); err != nil {
+			return
+		}
+		data := ped.Bytes()
+		ped.SetBuf(data)
+		ped.Unmarshal(&nst)
+	}
+}
+
+func TestGob(t *testing.T) {
+	prepareEnv(t)
+	st := &TestItem{Name: "gob", Age: 10}
+	itemx := &Item{Key: "gob", Object: st, Flags: FlagGOB}
+	if err := c.Set(itemx); err != nil {
+		t.Errorf("conn.Set() error(%v)", err)
+	}
+	if r, err := c.Get("gob"); err != nil {
+		t.Errorf("conn.Get() error(%v)", err)
+	} else {
+		var nst TestItem
+		scanAndCompare(t, r, st, &nst)
+	}
+}
+
+func TestGobGzip(t *testing.T) {
+	prepareEnv(t)
+	st := &TestItem{Name: "gobgzip", Age: 10}
+	itemx := &Item{Key: "gobgzip", Object: st, Flags: FlagGOB | FlagGzip}
+	if err := c.Set(itemx); err != nil {
+		t.Errorf("conn.Set() error(%v)", err)
+	}
+	if r, err := c.Get("gobgzip"); err != nil {
+		t.Errorf("conn.Get() error(%v)", err)
+	} else {
+		var nst TestItem
+		scanAndCompare(t, r, st, &nst)
+	}
+}
+
+func TestGzip(t *testing.T) {
+	prepareEnv(t)
+	st := &TestItem{Name: "gzip", Age: 123}
+	itemx := &Item{Key: "gzip", Object: st, Flags: FlagGOB | FlagGzip}
+	if err := c.Set(itemx); err != nil {
+		t.Errorf("conn.Set() error(%v)", err)
+	}
+	if r, err := c.Get("gzip"); err != nil {
+		t.Errorf("conn.Get() error(%v)", err)
+	} else {
+		var nst TestItem
+		scanAndCompare(t, r, st, &nst)
+	}
+}
+
+func TestProtobuf(t *testing.T) {
+	prepareEnv(t)
+	var (
+		err error
+		// value []byte
+		r   *Item
+		nst test.TestItem
+	)
+	st := &test.TestItem{Name: "proto", Age: 3021}
+	itemx := &Item{Key: "proto", Object: st, Flags: FlagProtobuf}
+	if err = c.Set(itemx); err != nil {
+		t.Errorf("conn.Set() error(%v)", err)
+	}
+	if r, err = c.Get("proto"); err != nil {
+		t.Errorf("conn.Get() error(%v)", err)
+	}
+	if err = c.Scan(r, &nst); err != nil {
+		t.Errorf("decode() error(%v)", err)
+		t.FailNow()
+	} else {
+		scanAndCompare2(t, r, st, &nst)
+	}
+}
+
+func TestProtobufGzip(t *testing.T) {
+	prepareEnv(t)
+	var (
+		err error
+		// value []byte
+		r   *Item
+		nst test.TestItem
+	)
+	st := &test.TestItem{Name: "protogzip", Age: 3021}
+	itemx := &Item{Key: "protogzip", Object: st, Flags: FlagProtobuf | FlagGzip}
+	if err = c.Set(itemx); err != nil {
+		t.Errorf("conn.Set() error(%v)", err)
+	}
+	if r, err = c.Get("protogzip"); err != nil {
+		t.Errorf("conn.Get() error(%v)", err)
+	}
+	if err = c.Scan(r, &nst); err != nil {
+		t.Errorf("decode() error(%v)", err)
+		t.FailNow()
+	} else {
+		scanAndCompare2(t, r, st, &nst)
+	}
+}
+
+func TestGet(t *testing.T) {
+	prepareEnv(t)
+	// get
+	if r, err := c.Get("test"); err != nil {
+		t.Errorf("conn.Get() error(%v)", err)
+	} else if r.Key != "test" || !bytes.Equal(r.Value, []byte("test")) || r.Flags != 0 {
+		t.Error("conn.Get() error, value")
+	}
+}
+
+func TestGetHasErr(t *testing.T) {
+	prepareEnv(t)
+
+	st := &TestItem{Name: "json", Age: 10}
+	itemx := &Item{Key: "test", Object: st, Flags: FlagJSON}
+	c.Set(itemx)
+
+	expected := errors.New("some error")
+	monkey.Patch(scanGetReply, func(line []byte, item *Item) (size int, err error) {
+		return 0, expected
+	})
+
+	if _, err := c.Get("test"); err.Error() != expected.Error() {
+		t.Errorf("conn.Get() unexpected error(%v)", err)
+	}
+	if err := c.(*conn).err; err.Error() != expected.Error() {
+		t.Errorf("unexpected error(%v)", err)
+	}
+}
+
+func TestGet2(t *testing.T) {
+	prepareEnv(t)
+	// get not exist
+	if _, err := c.Get("not_exist"); err != ErrNotFound {
+		t.Errorf("conn.Get() error(%v)", err)
+	}
+}
+
+func TestGetMulti(t *testing.T) {
+	prepareEnv(t)
+	// getMulti
+	if _, err := c.GetMulti(s); err != nil {
+		t.Errorf("conn.GetMulti() error(%v)", err)
+	}
+}
+
+func TestGetMulti2(t *testing.T) {
+	prepareEnv(t)
+	//set
+	if err := c.Set(item); err != nil {
+		t.Errorf("conn.Set() error(%v)", err)
+	}
+	if err := c.Set(item2); err != nil {
+		t.Errorf("conn.Set() error(%v)", err)
+	}
+	if res, err := c.GetMulti(s); err != nil {
+		t.Errorf("conn.Get() error(%v)", err)
+	} else {
+		if len(res) != 2 {
+			t.Error("conn.Get() error, length", len(res))
+		}
+		reply := res["test"]
+		compareItem2(t, reply, item)
+		reply = res["test1"]
+		compareItem2(t, reply, item2)
+	}
+}
+
+func TestIncrement(t *testing.T) {
+	// set
+	if err := c.Set(item3); err != nil {
+		t.Errorf("conn.Set() error(%v)", err)
+	}
+	// incr
+	if d, err := c.Increment("test2", 4); err != nil {
+		t.Errorf("conn.Set() error(%v)", err)
+	} else {
+		if d != 4 {
+			t.Error("conn.IncrDecr value error")
+		}
+	}
+}
+
+func TestDecrement(t *testing.T) {
+	// decr
+	if d, err := c.Decrement("test2", 3); err != nil {
+		t.Errorf("conn.Store() error(%v)", err)
+	} else {
+		if d != 1 {
+			t.Error("conn.IncrDecr value error", d)
+		}
+	}
+}
+
+func TestTouch(t *testing.T) {
+	// touch
+	if err := c.Touch("test2", 1); err != nil {
+		t.Errorf("conn.Touch error(%v)", err)
+	}
+}
+
+func TestCompareAndSwap(t *testing.T) {
+	prepareEnv(t)
+	if err := c.Set(item3); err != nil {
+		t.Errorf("conn.Set() error(%v)", err)
+	}
+	//cas
+	if r, err := c.Get("test2"); err != nil {
+		t.Errorf("conn.Get() error(%v)", err)
+	} else {
+		r.Value = []byte("fuck")
+		if err := c.CompareAndSwap(r); err != nil {
+			t.Errorf("conn.CompareAndSwap() error(%v)", err)
+		}
+		if r, err := c.Get("test2"); err != nil {
+			t.Errorf("conn.Get() error(%v)", err)
+		} else {
+			itemx := &Item{Key: "test2", Value: []byte("fuck"), Flags: 0}
+			compareItem2(t, r, itemx)
+		}
+	}
+}
+
+func TestReplace(t *testing.T) {
+	prepareEnv(t)
+	if err := c.Set(item); err != nil {
+		t.Errorf("conn.Set() error(%v)", err)
+	}
+	if r, err := c.Get("test"); err != nil {
+		t.Errorf("conn.Get() error(%v)", err)
+	} else {
+		r.Value = []byte("go")
+		if err := c.Replace(r); err != nil {
+			t.Errorf("conn.CompareAndSwap() error(%v)", err)
+		}
+		if r, err := c.Get("test"); err != nil {
+			t.Errorf("conn.Get() error(%v)", err)
+		} else {
+			itemx := &Item{Key: "test", Value: []byte("go"), Flags: 0}
+			compareItem2(t, r, itemx)
+		}
+
+	}
+}
+
+func scanAndCompare(t *testing.T, item *Item, st *TestItem, nst *TestItem) {
+	if err := c.Scan(item, nst); err != nil {
+		t.Errorf("decode() error(%v)", err)
+		t.FailNow()
+	}
+	if !st.Compare(nst) {
+		t.Errorf("st: %v, use of closed network connection nst: %v", st, &nst)
+		t.FailNow()
+	}
+}
+
+func scanAndCompare2(t *testing.T, item *Item, st *test.TestItem, nst *test.TestItem) {
+	if err := c.Scan(item, nst); err != nil {
+		t.Errorf("decode() error(%v)", err)
+		t.FailNow()
+	}
+	if st.Age != nst.Age || st.Name != nst.Name {
+		t.Errorf("st: %v, use of closed network connection nst: %v", st, &nst)
+		t.FailNow()
+	}
+}
+
+func compareItem2(t *testing.T, r, item *Item) {
+	if r.Key != item.Key || !bytes.Equal(r.Value, item.Value) || r.Flags != item.Flags {
+		t.Error("conn.Get() error, value")
+	}
+}
+
+func Test_legalKey(t *testing.T) {
+	type args struct {
+		key string
+	}
+	tests := []struct {
+		name string
+		args args
+		want bool
+	}{
+		{
+			name: "test empty key",
+			want: false,
+		},
+		{
+			name: "test too large key",
+			args: args{func() string {
+				var data []byte
+				for i := 0; i < 255; i++ {
+					data = append(data, 'k')
+				}
+				return string(data)
+			}()},
+			want: false,
+		},
+		{
+			name: "test invalid char",
+			args: args{"hello world"},
+			want: false,
+		},
+		{
+			name: "test invalid char",
+			args: args{string([]byte{0x7f})},
+			want: false,
+		},
+		{
+			name: "test normal key",
+			args: args{"hello"},
+			want: true,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := legalKey(tt.args.key); got != tt.want {
+				t.Errorf("legalKey() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}

library/cache/memcache/errors.go

@@ -0,0 +1,76 @@
+package memcache
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+
+	pkgerr "github.com/pkg/errors"
+)
+
+var (
+	// ErrNotFound not found
+	ErrNotFound = errors.New("memcache: key not found")
+	// ErrExists exists
+	ErrExists = errors.New("memcache: key exists")
+	// ErrNotStored not stored
+	ErrNotStored = errors.New("memcache: key not stored")
+	// ErrCASConflict means that a CompareAndSwap call failed due to the
+	// cached value being modified between the Get and the CompareAndSwap.
+	// If the cached value was simply evicted rather than replaced,
+	// ErrNotStored will be returned instead.
+	ErrCASConflict = errors.New("memcache: compare-and-swap conflict")
+
+	// ErrPoolExhausted is returned from a pool connection method (Store, Get,
+	// Delete, IncrDecr, Err) when the maximum number of database connections
+	// in the pool has been reached.
+	ErrPoolExhausted = errors.New("memcache: connection pool exhausted")
+	// ErrPoolClosed pool closed
+	ErrPoolClosed = errors.New("memcache: connection pool closed")
+	// ErrConnClosed conn closed
+	ErrConnClosed = errors.New("memcache: connection closed")
+	// ErrMalformedKey is returned when an invalid key is used.
+	// Keys must be at maximum 250 bytes long and not
+	// contain whitespace or control characters.
+	ErrMalformedKey = errors.New("memcache: malformed key is too long or contains invalid characters")
+	// ErrValueSize item value size must less than 1mb
+	ErrValueSize = errors.New("memcache: item value size must not greater than 1mb")
+	// ErrStat stat error for monitor
+	ErrStat = errors.New("memcache unexpected errors")
+	// ErrItem item nil.
+	ErrItem = errors.New("memcache: item object nil")
+	// ErrItemObject object type Assertion failed
+	ErrItemObject = errors.New("memcache: item object protobuf type assertion failed")
+)
+
+type protocolError string
+
+func (pe protocolError) Error() string {
+	return fmt.Sprintf("memcache: %s (possible server error or unsupported concurrent read by application)", string(pe))
+}
+
+func formatErr(err error) string {
+	e := pkgerr.Cause(err)
+	switch e {
+	case ErrNotFound, ErrExists, ErrNotStored, nil:
+		return ""
+	default:
+		es := e.Error()
+		switch {
+		case strings.HasPrefix(es, "read"):
+			return "read timeout"
+		case strings.HasPrefix(es, "dial"):
+			return "dial timeout"
+		case strings.HasPrefix(es, "write"):
+			return "write timeout"
+		case strings.Contains(es, "EOF"):
+			return "eof"
+		case strings.Contains(es, "reset"):
+			return "reset"
+		case strings.Contains(es, "broken"):
+			return "broken pipe"
+		default:
+			return "unexpected err"
+		}
+	}
+}

library/cache/memcache/memcache.go

@@ -0,0 +1,136 @@
+package memcache
+
+import (
+	"context"
+)
+
+// Error represents an error returned in a command reply.
+type Error string
+
+func (err Error) Error() string { return string(err) }
+
+const (
+	// Flag, 15(encoding) bit+ 17(compress) bit
+
+	// FlagRAW default flag.
+	FlagRAW = uint32(0)
+	// FlagGOB gob encoding.
+	FlagGOB = uint32(1) << 0
+	// FlagJSON json encoding.
+	FlagJSON = uint32(1) << 1
+	// FlagProtobuf protobuf
+	FlagProtobuf = uint32(1) << 2
+
+	_flagEncoding = uint32(0xFFFF8000)
+
+	// FlagGzip gzip compress.
+	FlagGzip = uint32(1) << 15
+
+	// left mv 31??? not work!!!
+	flagLargeValue = uint32(1) << 30
+)
+
+// Item is an reply to be got or stored in a memcached server.
+type Item struct {
+	// Key is the Item's key (250 bytes maximum).
+	Key string
+
+	// Value is the Item's value.
+	Value []byte
+
+	// Object is the Item's object for use codec.
+	Object interface{}
+
+	// Flags are server-opaque flags whose semantics are entirely
+	// up to the app.
+	Flags uint32
+
+	// Expiration is the cache expiration time, in seconds: either a relative
+	// time from now (up to 1 month), or an absolute Unix epoch time.
+	// Zero means the Item has no expiration time.
+	Expiration int32
+
+	// Compare and swap ID.
+	cas uint64
+}
+
+// Conn represents a connection to a Memcache server.
+// Command Reference: https://github.com/memcached/memcached/wiki/Commands
+type Conn interface {
+	// Close closes the connection.
+	Close() error
+
+	// Err returns a non-nil value if the connection is broken. The returned
+	// value is either the first non-nil value returned from the underlying
+	// network connection or a protocol parsing error. Applications should
+	// close broken connections.
+	Err() error
+
+	// Add writes the given item, if no value already exists for its key.
+	// ErrNotStored is returned if that condition is not met.
+	Add(item *Item) error
+
+	// Set writes the given item, unconditionally.
+	Set(item *Item) error
+
+	// Replace writes the given item, but only if the server *does* already
+	// hold data for this key.
+	Replace(item *Item) error
+
+	// Get sends a command to the server for gets data.
+	Get(key string) (*Item, error)
+
+	// GetMulti is a batch version of Get. The returned map from keys to items
+	// may have fewer elements than the input slice, due to memcache cache
+	// misses. Each key must be at most 250 bytes in length.
+	// If no error is returned, the returned map will also be non-nil.
+	GetMulti(keys []string) (map[string]*Item, error)
+
+	// Delete deletes the item with the provided key.
+	// The error ErrCacheMiss is returned if the item didn't already exist in
+	// the cache.
+	Delete(key string) error
+
+	// Increment atomically increments key by delta. The return value is the
+	// new value after being incremented or an error. If the value didn't exist
+	// in memcached the error is ErrCacheMiss. The value in memcached must be
+	// an decimal number, or an error will be returned.
+	// On 64-bit overflow, the new value wraps around.
+	Increment(key string, delta uint64) (newValue uint64, err error)
+
+	// Decrement atomically decrements key by delta. The return value is the
+	// new value after being decremented or an error. If the value didn't exist
+	// in memcached the error is ErrCacheMiss. The value in memcached must be
+	// an decimal number, or an error will be returned. On underflow, the new
+	// value is capped at zero and does not wrap around.
+	Decrement(key string, delta uint64) (newValue uint64, err error)
+
+	// CompareAndSwap writes the given item that was previously returned by
+	// Get, if the value was neither modified or evicted between the Get and
+	// the CompareAndSwap calls. The item's Key should not change between calls
+	// but all other item fields may differ. ErrCASConflict is returned if the
+	// value was modified in between the calls.
+	// ErrNotStored is returned if the value was evicted in between the calls.
+	CompareAndSwap(item *Item) error
+
+	// Touch updates the expiry for the given key. The seconds parameter is
+	// either a Unix timestamp or, if seconds is less than 1 month, the number
+	// of seconds into the future at which time the item will expire.
+	//ErrCacheMiss is returned if the key is not in the cache. The key must be
+	// at most 250 bytes in length.
+	Touch(key string, seconds int32) (err error)
+
+	// Scan converts value read from the memcache into the following
+	// common Go types and special types:
+	//
+	//    *string
+	//    *[]byte
+	//    *interface{}
+	//
+	Scan(item *Item, v interface{}) (err error)
+
+	// WithContext return a Conn with its context changed to ctx
+	// the context controls the entire lifetime of Conn before you change it
+	// NOTE: this method is not thread-safe
+	WithContext(ctx context.Context) Conn
+}

library/cache/memcache/memcache_test.go

@@ -0,0 +1,210 @@
+package memcache
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"testing"
+	"time"
+
+	"go-common/library/container/pool"
+	xtime "go-common/library/time"
+)
+
+var testMemcacheAddr = "127.0.0.1:11211"
+
+var testConfig = &Config{
+	Config: &pool.Config{
+		Active:      10,
+		Idle:        10,
+		IdleTimeout: xtime.Duration(time.Second),
+		WaitTimeout: xtime.Duration(time.Second),
+		Wait:        false,
+	},
+	Proto:        "tcp",
+	DialTimeout:  xtime.Duration(time.Second),
+	ReadTimeout:  xtime.Duration(time.Second),
+	WriteTimeout: xtime.Duration(time.Second),
+}
+
+func init() {
+	if addr := os.Getenv("TEST_MEMCACHE_ADDR"); addr != "" {
+		testMemcacheAddr = addr
+	}
+	testConfig.Addr = testMemcacheAddr
+}
+
+func TestMain(m *testing.M) {
+	testClient = New(testConfig)
+	m.Run()
+	testClient.Close()
+	os.Exit(0)
+}
+
+func ExampleConn_set() {
+	var (
+		err    error
+		value  []byte
+		conn   Conn
+		expire int32 = 100
+		p            = struct {
+			Name string
+			Age  int64
+		}{"golang", 10}
+	)
+	cnop := DialConnectTimeout(time.Duration(time.Second))
+	rdop := DialReadTimeout(time.Duration(time.Second))
+	wrop := DialWriteTimeout(time.Duration(time.Second))
+	if value, err = json.Marshal(p); err != nil {
+		fmt.Println(err)
+		return
+	}
+	if conn, err = Dial("tcp", testMemcacheAddr, cnop, rdop, wrop); err != nil {
+		fmt.Println(err)
+		return
+	}
+	// FlagRAW test
+	itemRaw := &Item{
+		Key:        "test_raw",
+		Value:      value,
+		Expiration: expire,
+	}
+	if err = conn.Set(itemRaw); err != nil {
+		fmt.Println(err)
+		return
+	}
+	// FlagGzip
+	itemGZip := &Item{
+		Key:        "test_gzip",
+		Value:      value,
+		Flags:      FlagGzip,
+		Expiration: expire,
+	}
+	if err = conn.Set(itemGZip); err != nil {
+		fmt.Println(err)
+		return
+	}
+	// FlagGOB
+	itemGOB := &Item{
+		Key:        "test_gob",
+		Object:     p,
+		Flags:      FlagGOB,
+		Expiration: expire,
+	}
+	if err = conn.Set(itemGOB); err != nil {
+		fmt.Println(err)
+		return
+	}
+	// FlagJSON
+	itemJSON := &Item{
+		Key:        "test_json",
+		Object:     p,
+		Flags:      FlagJSON,
+		Expiration: expire,
+	}
+	if err = conn.Set(itemJSON); err != nil {
+		fmt.Println(err)
+		return
+	}
+	// FlagJSON | FlagGzip
+	itemJSONGzip := &Item{
+		Key:        "test_jsonGzip",
+		Object:     p,
+		Flags:      FlagJSON | FlagGzip,
+		Expiration: expire,
+	}
+	if err = conn.Set(itemJSONGzip); err != nil {
+		fmt.Println(err)
+		return
+	}
+	// Output:
+}
+
+func ExampleConn_get() {
+	var (
+		err   error
+		item2 *Item
+		conn  Conn
+		p     struct {
+			Name string
+			Age  int64
+		}
+	)
+	cnop := DialConnectTimeout(time.Duration(time.Second))
+	rdop := DialReadTimeout(time.Duration(time.Second))
+	wrop := DialWriteTimeout(time.Duration(time.Second))
+	if conn, err = Dial("tcp", testMemcacheAddr, cnop, rdop, wrop); err != nil {
+		fmt.Println(err)
+		return
+	}
+	if item2, err = conn.Get("test_raw"); err != nil {
+		fmt.Println(err)
+	} else {
+		if err = conn.Scan(item2, &p); err != nil {
+			fmt.Printf("FlagRAW conn.Scan error(%v)\n", err)
+			return
+		}
+	}
+	// FlagGZip
+	if item2, err = conn.Get("test_gzip"); err != nil {
+		fmt.Println(err)
+	} else {
+		if err = conn.Scan(item2, &p); err != nil {
+			fmt.Printf("FlagGZip conn.Scan error(%v)\n", err)
+			return
+		}
+	}
+	// FlagGOB
+	if item2, err = conn.Get("test_gob"); err != nil {
+		fmt.Println(err)
+	} else {
+		if err = conn.Scan(item2, &p); err != nil {
+			fmt.Printf("FlagGOB conn.Scan error(%v)\n", err)
+			return
+		}
+	}
+	// FlagJSON
+	if item2, err = conn.Get("test_json"); err != nil {
+		fmt.Println(err)
+	} else {
+		if err = conn.Scan(item2, &p); err != nil {
+			fmt.Printf("FlagJSON conn.Scan error(%v)\n", err)
+			return
+		}
+	}
+	// Output:
+}
+
+func ExampleConn_getMulti() {
+	var (
+		err  error
+		conn Conn
+		res  map[string]*Item
+		keys = []string{"test_raw", "test_gzip"}
+		p    struct {
+			Name string
+			Age  int64
+		}
+	)
+	cnop := DialConnectTimeout(time.Duration(time.Second))
+	rdop := DialReadTimeout(time.Duration(time.Second))
+	wrop := DialWriteTimeout(time.Duration(time.Second))
+	if conn, err = Dial("tcp", testMemcacheAddr, cnop, rdop, wrop); err != nil {
+		fmt.Println(err)
+		return
+	}
+	if res, err = conn.GetMulti(keys); err != nil {
+		fmt.Printf("conn.GetMulti(%v) error(%v)", keys, err)
+		return
+	}
+	for _, v := range res {
+		if err = conn.Scan(v, &p); err != nil {
+			fmt.Printf("conn.Scan error(%v)\n", err)
+			return
+		}
+		fmt.Println(p)
+	}
+	// Output:
+	//{golang 10}
+	//{golang 10}
+}

library/cache/memcache/mock.go

@@ -0,0 +1,59 @@
+package memcache
+
+import (
+	"context"
+)
+
+// MockErr for unit test.
+type MockErr struct {
+	Error error
+}
+
+var _ Conn = MockErr{}
+
+// MockWith return a mock conn.
+func MockWith(err error) MockErr {
+	return MockErr{Error: err}
+}
+
+// Err .
+func (m MockErr) Err() error { return m.Error }
+
+// Close .
+func (m MockErr) Close() error { return m.Error }
+
+// Add .
+func (m MockErr) Add(item *Item) error { return m.Error }
+
+// Set .
+func (m MockErr) Set(item *Item) error { return m.Error }
+
+// Replace .
+func (m MockErr) Replace(item *Item) error { return m.Error }
+
+// CompareAndSwap .
+func (m MockErr) CompareAndSwap(item *Item) error { return m.Error }
+
+// Get .
+func (m MockErr) Get(key string) (*Item, error) { return nil, m.Error }
+
+// GetMulti .
+func (m MockErr) GetMulti(keys []string) (map[string]*Item, error) { return nil, m.Error }
+
+// Touch .
+func (m MockErr) Touch(key string, timeout int32) error { return m.Error }
+
+// Delete .
+func (m MockErr) Delete(key string) error { return m.Error }
+
+// Increment .
+func (m MockErr) Increment(key string, delta uint64) (uint64, error) { return 0, m.Error }
+
+// Decrement .
+func (m MockErr) Decrement(key string, delta uint64) (uint64, error) { return 0, m.Error }
+
+// Scan .
+func (m MockErr) Scan(item *Item, v interface{}) error { return m.Error }
+
+// WithContext .
+func (m MockErr) WithContext(ctx context.Context) Conn { return m }

library/cache/memcache/pool.go

@@ -0,0 +1,197 @@
+package memcache
+
+import (
+	"context"
+	"io"
+	"time"
+
+	"go-common/library/container/pool"
+	"go-common/library/stat"
+	xtime "go-common/library/time"
+)
+
+var stats = stat.Cache
+
+// Config memcache config.
+type Config struct {
+	*pool.Config
+
+	Name         string // memcache name, for trace
+	Proto        string
+	Addr         string
+	DialTimeout  xtime.Duration
+	ReadTimeout  xtime.Duration
+	WriteTimeout xtime.Duration
+}
+
+// Pool memcache connection pool struct.
+type Pool struct {
+	p pool.Pool
+	c *Config
+}
+
+// NewPool new a memcache conn pool.
+func NewPool(c *Config) (p *Pool) {
+	if c.DialTimeout <= 0 || c.ReadTimeout <= 0 || c.WriteTimeout <= 0 {
+		panic("must config memcache timeout")
+	}
+	p1 := pool.NewList(c.Config)
+	cnop := DialConnectTimeout(time.Duration(c.DialTimeout))
+	rdop := DialReadTimeout(time.Duration(c.ReadTimeout))
+	wrop := DialWriteTimeout(time.Duration(c.WriteTimeout))
+	p1.New = func(ctx context.Context) (io.Closer, error) {
+		conn, err := Dial(c.Proto, c.Addr, cnop, rdop, wrop)
+		return &traceConn{Conn: conn, address: c.Addr}, err
+	}
+	p = &Pool{p: p1, c: c}
+	return
+}
+
+// Get gets a connection. The application must close the returned connection.
+// This method always returns a valid connection so that applications can defer
+// error handling to the first use of the connection. If there is an error
+// getting an underlying connection, then the connection Err, Do, Send, Flush
+// and Receive methods return that error.
+func (p *Pool) Get(ctx context.Context) Conn {
+	c, err := p.p.Get(ctx)
+	if err != nil {
+		return errorConnection{err}
+	}
+	c1, _ := c.(Conn)
+	return &pooledConnection{p: p, c: c1.WithContext(ctx), ctx: ctx}
+}
+
+// Close release the resources used by the pool.
+func (p *Pool) Close() error {
+	return p.p.Close()
+}
+
+type pooledConnection struct {
+	p   *Pool
+	c   Conn
+	ctx context.Context
+}
+
+func pstat(key string, t time.Time, err error) {
+	stats.Timing(key, int64(time.Since(t)/time.Millisecond))
+	if err != nil {
+		if msg := formatErr(err); msg != "" {
+			stats.Incr("memcache", msg)
+		}
+	}
+}
+
+func (pc *pooledConnection) Close() error {
+	c := pc.c
+	if _, ok := c.(errorConnection); ok {
+		return nil
+	}
+	pc.c = errorConnection{ErrConnClosed}
+	pc.p.p.Put(context.Background(), c, c.Err() != nil)
+	return nil
+}
+
+func (pc *pooledConnection) Err() error {
+	return pc.c.Err()
+}
+
+func (pc *pooledConnection) Set(item *Item) (err error) {
+	now := time.Now()
+	err = pc.c.Set(item)
+	pstat("memcache:set", now, err)
+	return
+}
+
+func (pc *pooledConnection) Add(item *Item) (err error) {
+	now := time.Now()
+	err = pc.c.Add(item)
+	pstat("memcache:add", now, err)
+	return
+}
+
+func (pc *pooledConnection) Replace(item *Item) (err error) {
+	now := time.Now()
+	err = pc.c.Replace(item)
+	pstat("memcache:replace", now, err)
+	return
+}
+
+func (pc *pooledConnection) CompareAndSwap(item *Item) (err error) {
+	now := time.Now()
+	err = pc.c.CompareAndSwap(item)
+	pstat("memcache:cas", now, err)
+	return
+}
+
+func (pc *pooledConnection) Get(key string) (r *Item, err error) {
+	now := time.Now()
+	r, err = pc.c.Get(key)
+	pstat("memcache:get", now, err)
+	return
+}
+
+func (pc *pooledConnection) GetMulti(keys []string) (res map[string]*Item, err error) {
+	// if keys is empty slice returns empty map direct
+	if len(keys) == 0 {
+		return make(map[string]*Item), nil
+	}
+	now := time.Now()
+	res, err = pc.c.GetMulti(keys)
+	pstat("memcache:gets", now, err)
+	return
+}
+
+func (pc *pooledConnection) Touch(key string, timeout int32) (err error) {
+	now := time.Now()
+	err = pc.c.Touch(key, timeout)
+	pstat("memcache:touch", now, err)
+	return
+}
+
+func (pc *pooledConnection) Scan(item *Item, v interface{}) error {
+	return pc.c.Scan(item, v)
+}
+
+func (pc *pooledConnection) WithContext(ctx context.Context) Conn {
+	// TODO: set context
+	pc.ctx = ctx
+	return pc
+}
+
+func (pc *pooledConnection) Delete(key string) (err error) {
+	now := time.Now()
+	err = pc.c.Delete(key)
+	pstat("memcache:delete", now, err)
+	return
+}
+
+func (pc *pooledConnection) Increment(key string, delta uint64) (newValue uint64, err error) {
+	now := time.Now()
+	newValue, err = pc.c.Increment(key, delta)
+	pstat("memcache:increment", now, err)
+	return
+}
+
+func (pc *pooledConnection) Decrement(key string, delta uint64) (newValue uint64, err error) {
+	now := time.Now()
+	newValue, err = pc.c.Decrement(key, delta)
+	pstat("memcache:decrement", now, err)
+	return
+}
+
+type errorConnection struct{ err error }
+
+func (ec errorConnection) Err() error                                         { return ec.err }
+func (ec errorConnection) Close() error                                       { return ec.err }
+func (ec errorConnection) Add(item *Item) error                               { return ec.err }
+func (ec errorConnection) Set(item *Item) error                               { return ec.err }
+func (ec errorConnection) Replace(item *Item) error                           { return ec.err }
+func (ec errorConnection) CompareAndSwap(item *Item) error                    { return ec.err }
+func (ec errorConnection) Get(key string) (*Item, error)                      { return nil, ec.err }
+func (ec errorConnection) GetMulti(keys []string) (map[string]*Item, error)   { return nil, ec.err }
+func (ec errorConnection) Touch(key string, timeout int32) error              { return ec.err }
+func (ec errorConnection) Delete(key string) error                            { return ec.err }
+func (ec errorConnection) Increment(key string, delta uint64) (uint64, error) { return 0, ec.err }
+func (ec errorConnection) Decrement(key string, delta uint64) (uint64, error) { return 0, ec.err }
+func (ec errorConnection) Scan(item *Item, v interface{}) error               { return ec.err }
+func (ec errorConnection) WithContext(ctx context.Context) Conn               { return ec }

library/cache/memcache/pool_test.go

@@ -0,0 +1,361 @@
+package memcache
+
+import (
+	"bytes"
+	"context"
+	"os"
+	"testing"
+	"time"
+
+	"go-common/library/container/pool"
+	xtime "go-common/library/time"
+)
+
+var p *Pool
+var config *Config
+
+func init() {
+	testMemcacheAddr := "127.0.0.1:11211"
+	if addr := os.Getenv("TEST_MEMCACHE_ADDR"); addr != "" {
+		testMemcacheAddr = addr
+	}
+	config = &Config{
+		Name:         "test",
+		Proto:        "tcp",
+		Addr:         testMemcacheAddr,
+		DialTimeout:  xtime.Duration(time.Second),
+		ReadTimeout:  xtime.Duration(time.Second),
+		WriteTimeout: xtime.Duration(time.Second),
+	}
+	config.Config = &pool.Config{
+		Active:      10,
+		Idle:        5,
+		IdleTimeout: xtime.Duration(90 * time.Second),
+	}
+}
+
+var itempool = &Item{
+	Key:        "testpool",
+	Value:      []byte("testpool"),
+	Flags:      0,
+	Expiration: 60,
+	cas:        0,
+}
+var itempool2 = &Item{
+	Key:        "test_count",
+	Value:      []byte("0"),
+	Flags:      0,
+	Expiration: 1000,
+	cas:        0,
+}
+
+type testObject struct {
+	Mid   int64
+	Value []byte
+}
+
+var largeValue = &Item{
+	Key:        "large_value",
+	Flags:      FlagGOB | FlagGzip,
+	Expiration: 1000,
+	cas:        0,
+}
+
+var largeValueBoundary = &Item{
+	Key:        "large_value",
+	Flags:      FlagGOB | FlagGzip,
+	Expiration: 1000,
+	cas:        0,
+}
+
+func prepareEnv2() {
+	if p != nil {
+		return
+	}
+	p = NewPool(config)
+}
+
+func TestPoolSet(t *testing.T) {
+	prepareEnv2()
+	conn := p.Get(context.Background())
+	defer conn.Close()
+	// set
+	if err := conn.Set(itempool); err != nil {
+		t.Errorf("memcache: set error(%v)", err)
+	} else {
+		t.Logf("memcache: set value: %s", item.Value)
+	}
+	if err := conn.Close(); err != nil {
+		t.Errorf("memcache: close error(%v)", err)
+	}
+}
+
+func TestPoolGet(t *testing.T) {
+	prepareEnv2()
+	key := "testpool"
+	conn := p.Get(context.Background())
+	defer conn.Close()
+	// get
+	if res, err := conn.Get(key); err != nil {
+		t.Errorf("memcache: get error(%v)", err)
+	} else {
+		t.Logf("memcache: get value: %s", res.Value)
+	}
+	if _, err := conn.Get("not_found"); err != ErrNotFound {
+		t.Errorf("memcache: expceted err is not found but got: %v", err)
+	}
+	if err := conn.Close(); err != nil {
+		t.Errorf("memcache: close error(%v)", err)
+	}
+}
+
+func TestPoolGetMulti(t *testing.T) {
+	prepareEnv2()
+	conn := p.Get(context.Background())
+	defer conn.Close()
+	s := []string{"testpool", "test1"}
+	// get
+	if res, err := conn.GetMulti(s); err != nil {
+		t.Errorf("memcache: gets error(%v)", err)
+	} else {
+		t.Logf("memcache: gets value: %d", len(res))
+	}
+	if err := conn.Close(); err != nil {
+		t.Errorf("memcache: close error(%v)", err)
+	}
+}
+
+func TestPoolTouch(t *testing.T) {
+	prepareEnv2()
+	key := "testpool"
+	conn := p.Get(context.Background())
+	defer conn.Close()
+	// touch
+	if err := conn.Touch(key, 10); err != nil {
+		t.Errorf("memcache: touch error(%v)", err)
+	}
+	if err := conn.Close(); err != nil {
+		t.Errorf("memcache: close error(%v)", err)
+	}
+}
+
+func TestPoolIncrement(t *testing.T) {
+	prepareEnv2()
+	key := "test_count"
+	conn := p.Get(context.Background())
+	defer conn.Close()
+	// set
+	if err := conn.Set(itempool2); err != nil {
+		t.Errorf("memcache: set error(%v)", err)
+	} else {
+		t.Logf("memcache: set value: 0")
+	}
+	// incr
+	if res, err := conn.Increment(key, 1); err != nil {
+		t.Errorf("memcache: incr error(%v)", err)
+	} else {
+		t.Logf("memcache: incr n: %d", res)
+		if res != 1 {
+			t.Errorf("memcache: expected res=1 but got %d", res)
+		}
+	}
+	// decr
+	if res, err := conn.Decrement(key, 1); err != nil {
+		t.Errorf("memcache: decr error(%v)", err)
+	} else {
+		t.Logf("memcache: decr n: %d", res)
+		if res != 0 {
+			t.Errorf("memcache: expected res=0 but got %d", res)
+		}
+	}
+	if err := conn.Close(); err != nil {
+		t.Errorf("memcache: close error(%v)", err)
+	}
+}
+
+func TestPoolErr(t *testing.T) {
+	prepareEnv2()
+	conn := p.Get(context.Background())
+	defer conn.Close()
+	if err := conn.Close(); err != nil {
+		t.Errorf("memcache: close error(%v)", err)
+	}
+	if err := conn.Err(); err == nil {
+		t.Errorf("memcache: err not nil")
+	} else {
+		t.Logf("memcache: err: %v", err)
+	}
+}
+
+func TestPoolCompareAndSwap(t *testing.T) {
+	prepareEnv2()
+	conn := p.Get(context.Background())
+	defer conn.Close()
+	key := "testpool"
+	//cas
+	if r, err := conn.Get(key); err != nil {
+		t.Errorf("conn.Get() error(%v)", err)
+	} else {
+		r.Value = []byte("shit")
+		if err := conn.CompareAndSwap(r); err != nil {
+			t.Errorf("conn.Get() error(%v)", err)
+		}
+		r, _ := conn.Get("testpool")
+		if r.Key != "testpool" || !bytes.Equal(r.Value, []byte("shit")) || r.Flags != 0 {
+			t.Error("conn.Get() error, value")
+		}
+		if err := conn.Close(); err != nil {
+			t.Errorf("memcache: close error(%v)", err)
+		}
+	}
+}
+
+func TestPoolDel(t *testing.T) {
+	prepareEnv2()
+	key := "testpool"
+	conn := p.Get(context.Background())
+	defer conn.Close()
+	// delete
+	if err := conn.Delete(key); err != nil {
+		t.Errorf("memcache: delete error(%v)", err)
+	} else {
+		t.Logf("memcache: delete key: %s", key)
+	}
+	if err := conn.Close(); err != nil {
+		t.Errorf("memcache: close error(%v)", err)
+	}
+}
+
+func BenchmarkMemcache(b *testing.B) {
+	c := &Config{
+		Name:         "test",
+		Proto:        "tcp",
+		Addr:         "127.0.0.1:11211",
+		DialTimeout:  xtime.Duration(time.Second),
+		ReadTimeout:  xtime.Duration(time.Second),
+		WriteTimeout: xtime.Duration(time.Second),
+	}
+	c.Config = &pool.Config{
+		Active:      10,
+		Idle:        5,
+		IdleTimeout: xtime.Duration(90 * time.Second),
+	}
+	p = NewPool(c)
+	b.ResetTimer()
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			conn := p.Get(context.Background())
+			if err := conn.Close(); err != nil {
+				b.Errorf("memcache: close error(%v)", err)
+			}
+		}
+	})
+	if err := p.Close(); err != nil {
+		b.Errorf("memcache: close error(%v)", err)
+	}
+}
+
+func TestPoolSetLargeValue(t *testing.T) {
+	var b bytes.Buffer
+	for i := 0; i < 4000000; i++ {
+		b.WriteByte(1)
+	}
+	obj := &testObject{}
+	obj.Mid = 1000
+	obj.Value = b.Bytes()
+	largeValue.Object = obj
+	prepareEnv2()
+	conn := p.Get(context.Background())
+	defer conn.Close()
+	// set
+	if err := conn.Set(largeValue); err != nil {
+		t.Errorf("memcache: set error(%v)", err)
+	}
+	if err := conn.Close(); err != nil {
+		t.Errorf("memcache: close error(%v)", err)
+	}
+}
+
+func TestPoolGetLargeValue(t *testing.T) {
+	prepareEnv2()
+	key := largeValue.Key
+	conn := p.Get(context.Background())
+	defer conn.Close()
+	// get
+	var err error
+	if _, err = conn.Get(key); err != nil {
+		t.Errorf("memcache: large get error(%+v)", err)
+	}
+}
+
+func TestPoolGetMultiLargeValue(t *testing.T) {
+	prepareEnv2()
+	conn := p.Get(context.Background())
+	defer conn.Close()
+	s := []string{largeValue.Key, largeValue.Key}
+	// get
+	if res, err := conn.GetMulti(s); err != nil {
+		t.Errorf("memcache: gets error(%v)", err)
+	} else {
+		t.Logf("memcache: gets value: %d", len(res))
+	}
+	if err := conn.Close(); err != nil {
+		t.Errorf("memcache: close error(%v)", err)
+	}
+}
+
+func TestPoolSetLargeValueBoundary(t *testing.T) {
+	var b bytes.Buffer
+	for i := 0; i < _largeValue; i++ {
+		b.WriteByte(1)
+	}
+	obj := &testObject{}
+	obj.Mid = 1000
+	obj.Value = b.Bytes()
+	largeValueBoundary.Object = obj
+	prepareEnv2()
+	conn := p.Get(context.Background())
+	defer conn.Close()
+	// set
+	if err := conn.Set(largeValueBoundary); err != nil {
+		t.Errorf("memcache: set error(%v)", err)
+	}
+	if err := conn.Close(); err != nil {
+		t.Errorf("memcache: close error(%v)", err)
+	}
+}
+
+func TestPoolGetLargeValueBoundary(t *testing.T) {
+	prepareEnv2()
+	key := largeValueBoundary.Key
+	conn := p.Get(context.Background())
+	defer conn.Close()
+	// get
+	var err error
+	if _, err = conn.Get(key); err != nil {
+		t.Errorf("memcache: large get error(%v)", err)
+	}
+}
+
+func TestPoolAdd(t *testing.T) {
+	var (
+		key  = "test_add"
+		item = &Item{
+			Key:        key,
+			Value:      []byte("0"),
+			Flags:      0,
+			Expiration: 60,
+			cas:        0,
+		}
+		conn = p.Get(context.Background())
+	)
+	defer conn.Close()
+	prepareEnv2()
+	conn.Delete(key)
+	if err := conn.Add(item); err != nil {
+		t.Errorf("memcache: add error(%v)", err)
+	}
+	if err := conn.Add(item); err != ErrNotStored {
+		t.Errorf("memcache: add error(%v)", err)
+	}
+}

library/cache/memcache/test/BUILD.bazel

@@ -0,0 +1,48 @@
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+load(
+    "@io_bazel_rules_go//proto:def.bzl",
+    "go_proto_library",
+)
+
+proto_library(
+    name = "proto_proto",
+    srcs = ["test.proto"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)
+
+go_proto_library(
+    name = "proto_go_proto",
+    compilers = ["@io_bazel_rules_go//proto:go_proto"],
+    importpath = "go-common/library/cache/memcache/test",
+    proto = ":proto_proto",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [],
+    embed = [":proto_go_proto"],
+    importpath = "go-common/library/cache/memcache/test",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = ["@com_github_golang_protobuf//proto:go_default_library"],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

library/cache/memcache/test/test.pb.go

@@ -0,0 +1,375 @@
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
+// source: test.proto
+
+/*
+	Package proto is a generated protocol buffer package.
+
+	It is generated from these files:
+		test.proto
+
+	It has these top-level messages:
+		TestItem
+*/
+package proto
+
+import proto1 "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+
+import io "io"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto1.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto1.ProtoPackageIsVersion2 // please upgrade the proto package
+
+type FOO int32
+
+const (
+	FOO_X FOO = 0
+)
+
+var FOO_name = map[int32]string{
+	0: "X",
+}
+var FOO_value = map[string]int32{
+	"X": 0,
+}
+
+func (x FOO) String() string {
+	return proto1.EnumName(FOO_name, int32(x))
+}
+func (FOO) EnumDescriptor() ([]byte, []int) { return fileDescriptorTest, []int{0} }
+
+type TestItem struct {
+	Name string `protobuf:"bytes,1,opt,name=Name,proto3" json:"Name,omitempty"`
+	Age  int32  `protobuf:"varint,2,opt,name=Age,proto3" json:"Age,omitempty"`
+}
+
+func (m *TestItem) Reset()                    { *m = TestItem{} }
+func (m *TestItem) String() string            { return proto1.CompactTextString(m) }
+func (*TestItem) ProtoMessage()               {}
+func (*TestItem) Descriptor() ([]byte, []int) { return fileDescriptorTest, []int{0} }
+
+func (m *TestItem) GetName() string {
+	if m != nil {
+		return m.Name
+	}
+	return ""
+}
+
+func (m *TestItem) GetAge() int32 {
+	if m != nil {
+		return m.Age
+	}
+	return 0
+}
+
+func init() {
+	proto1.RegisterType((*TestItem)(nil), "proto.TestItem")
+	proto1.RegisterEnum("proto.FOO", FOO_name, FOO_value)
+}
+func (m *TestItem) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *TestItem) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if len(m.Name) > 0 {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintTest(dAtA, i, uint64(len(m.Name)))
+		i += copy(dAtA[i:], m.Name)
+	}
+	if m.Age != 0 {
+		dAtA[i] = 0x10
+		i++
+		i = encodeVarintTest(dAtA, i, uint64(m.Age))
+	}
+	return i, nil
+}
+
+func encodeFixed64Test(dAtA []byte, offset int, v uint64) int {
+	dAtA[offset] = uint8(v)
+	dAtA[offset+1] = uint8(v >> 8)
+	dAtA[offset+2] = uint8(v >> 16)
+	dAtA[offset+3] = uint8(v >> 24)
+	dAtA[offset+4] = uint8(v >> 32)
+	dAtA[offset+5] = uint8(v >> 40)
+	dAtA[offset+6] = uint8(v >> 48)
+	dAtA[offset+7] = uint8(v >> 56)
+	return offset + 8
+}
+func encodeFixed32Test(dAtA []byte, offset int, v uint32) int {
+	dAtA[offset] = uint8(v)
+	dAtA[offset+1] = uint8(v >> 8)
+	dAtA[offset+2] = uint8(v >> 16)
+	dAtA[offset+3] = uint8(v >> 24)
+	return offset + 4
+}
+func encodeVarintTest(dAtA []byte, offset int, v uint64) int {
+	for v >= 1<<7 {
+		dAtA[offset] = uint8(v&0x7f | 0x80)
+		v >>= 7
+		offset++
+	}
+	dAtA[offset] = uint8(v)
+	return offset + 1
+}
+func (m *TestItem) Size() (n int) {
+	var l int
+	_ = l
+	l = len(m.Name)
+	if l > 0 {
+		n += 1 + l + sovTest(uint64(l))
+	}
+	if m.Age != 0 {
+		n += 1 + sovTest(uint64(m.Age))
+	}
+	return n
+}
+
+func sovTest(x uint64) (n int) {
+	for {
+		n++
+		x >>= 7
+		if x == 0 {
+			break
+		}
+	}
+	return n
+}
+func sozTest(x uint64) (n int) {
+	return sovTest(uint64((x << 1) ^ uint64((int64(x) >> 63))))
+}
+func (m *TestItem) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowTest
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: TestItem: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: TestItem: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTest
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthTest
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Name = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 2:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Age", wireType)
+			}
+			m.Age = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTest
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Age |= (int32(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		default:
+			iNdEx = preIndex
+			skippy, err := skipTest(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthTest
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func skipTest(dAtA []byte) (n int, err error) {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return 0, ErrIntOverflowTest
+			}
+			if iNdEx >= l {
+				return 0, io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		wireType := int(wire & 0x7)
+		switch wireType {
+		case 0:
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return 0, ErrIntOverflowTest
+				}
+				if iNdEx >= l {
+					return 0, io.ErrUnexpectedEOF
+				}
+				iNdEx++
+				if dAtA[iNdEx-1] < 0x80 {
+					break
+				}
+			}
+			return iNdEx, nil
+		case 1:
+			iNdEx += 8
+			return iNdEx, nil
+		case 2:
+			var length int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return 0, ErrIntOverflowTest
+				}
+				if iNdEx >= l {
+					return 0, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				length |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			iNdEx += length
+			if length < 0 {
+				return 0, ErrInvalidLengthTest
+			}
+			return iNdEx, nil
+		case 3:
+			for {
+				var innerWire uint64
+				var start int = iNdEx
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return 0, ErrIntOverflowTest
+					}
+					if iNdEx >= l {
+						return 0, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					innerWire |= (uint64(b) & 0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				innerWireType := int(innerWire & 0x7)
+				if innerWireType == 4 {
+					break
+				}
+				next, err := skipTest(dAtA[start:])
+				if err != nil {
+					return 0, err
+				}
+				iNdEx = start + next
+			}
+			return iNdEx, nil
+		case 4:
+			return iNdEx, nil
+		case 5:
+			iNdEx += 4
+			return iNdEx, nil
+		default:
+			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
+		}
+	}
+	panic("unreachable")
+}
+
+var (
+	ErrInvalidLengthTest = fmt.Errorf("proto: negative length found during unmarshaling")
+	ErrIntOverflowTest   = fmt.Errorf("proto: integer overflow")
+)
+
+func init() { proto1.RegisterFile("test.proto", fileDescriptorTest) }
+
+var fileDescriptorTest = []byte{
+	// 122 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xe2, 0x2a, 0x49, 0x2d, 0x2e,
+	0xd1, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x62, 0x05, 0x53, 0x4a, 0x06, 0x5c, 0x1c, 0x21, 0xa9,
+	0xc5, 0x25, 0x9e, 0x25, 0xa9, 0xb9, 0x42, 0x42, 0x5c, 0x2c, 0x7e, 0x89, 0xb9, 0xa9, 0x12, 0x8c,
+	0x0a, 0x8c, 0x1a, 0x9c, 0x41, 0x60, 0xb6, 0x90, 0x00, 0x17, 0xb3, 0x63, 0x7a, 0xaa, 0x04, 0x93,
+	0x02, 0xa3, 0x06, 0x6b, 0x10, 0x88, 0xa9, 0xc5, 0xc3, 0xc5, 0xec, 0xe6, 0xef, 0x2f, 0xc4, 0xca,
+	0xc5, 0x18, 0x21, 0xc0, 0xe0, 0x24, 0x70, 0xe2, 0x91, 0x1c, 0xe3, 0x85, 0x47, 0x72, 0x8c, 0x0f,
+	0x1e, 0xc9, 0x31, 0xce, 0x78, 0x2c, 0xc7, 0x90, 0xc4, 0x06, 0x36, 0xd8, 0x18, 0x10, 0x00, 0x00,
+	0xff, 0xff, 0x16, 0x80, 0x60, 0x15, 0x6d, 0x00, 0x00, 0x00,
+}

library/cache/memcache/test/test.proto

@@ -0,0 +1,12 @@
+syntax = "proto3";  
+package proto;
+
+enum FOO 
+{ 
+    X = 0; 
+};
+
+message TestItem{
+    string Name = 1;  
+    int32 Age = 2;    
+}

library/cache/memcache/trace.go

@@ -0,0 +1,101 @@
+package memcache
+
+import (
+	"context"
+	"strconv"
+	"strings"
+
+	"go-common/library/net/trace"
+)
+
+const (
+	_traceFamily        = "memcache"
+	_traceSpanKind      = "client"
+	_traceComponentName = "library/cache/memcache"
+	_tracePeerService   = "memcache"
+)
+
+type traceConn struct {
+	Conn
+	ctx     context.Context
+	address string
+}
+
+func (t *traceConn) setTrace(action, statement string) func(error) error {
+	parent, ok := trace.FromContext(t.ctx)
+	if !ok {
+		return func(err error) error { return err }
+	}
+	span := parent.Fork(_traceFamily, "Memcache:"+action)
+	span.SetTag(
+		trace.String(trace.TagSpanKind, _traceSpanKind),
+		trace.String(trace.TagComponent, _traceComponentName),
+		trace.String(trace.TagPeerService, _tracePeerService),
+		trace.String(trace.TagPeerAddress, t.address),
+		trace.String(trace.TagDBStatement, action+" "+statement),
+	)
+	return func(err error) error {
+		span.Finish(&err)
+		return err
+	}
+}
+
+func (t *traceConn) WithContext(ctx context.Context) Conn {
+	t.ctx = ctx
+	t.Conn = t.Conn.WithContext(ctx)
+	return t
+}
+
+func (t *traceConn) Add(item *Item) error {
+	finishFn := t.setTrace("Add", item.Key)
+	return finishFn(t.Conn.Add(item))
+}
+
+func (t *traceConn) Set(item *Item) error {
+	finishFn := t.setTrace("Set", item.Key)
+	return finishFn(t.Conn.Set(item))
+}
+
+func (t *traceConn) Replace(item *Item) error {
+	finishFn := t.setTrace("Replace", item.Key)
+	return finishFn(t.Conn.Replace(item))
+}
+
+func (t *traceConn) Get(key string) (*Item, error) {
+	finishFn := t.setTrace("Get", key)
+	item, err := t.Conn.Get(key)
+	return item, finishFn(err)
+}
+
+func (t *traceConn) GetMulti(keys []string) (map[string]*Item, error) {
+	finishFn := t.setTrace("GetMulti", strings.Join(keys, " "))
+	items, err := t.Conn.GetMulti(keys)
+	return items, finishFn(err)
+}
+
+func (t *traceConn) Delete(key string) error {
+	finishFn := t.setTrace("Delete", key)
+	return finishFn(t.Conn.Delete(key))
+}
+
+func (t *traceConn) Increment(key string, delta uint64) (newValue uint64, err error) {
+	finishFn := t.setTrace("Increment", key+" "+strconv.FormatUint(delta, 10))
+	newValue, err = t.Conn.Increment(key, delta)
+	return newValue, finishFn(err)
+}
+
+func (t *traceConn) Decrement(key string, delta uint64) (newValue uint64, err error) {
+	finishFn := t.setTrace("Decrement", key+" "+strconv.FormatUint(delta, 10))
+	newValue, err = t.Conn.Decrement(key, delta)
+	return newValue, finishFn(err)
+}
+
+func (t *traceConn) CompareAndSwap(item *Item) error {
+	finishFn := t.setTrace("CompareAndSwap", item.Key)
+	return finishFn(t.Conn.CompareAndSwap(item))
+}
+
+func (t *traceConn) Touch(key string, seconds int32) (err error) {
+	finishFn := t.setTrace("Touch", key+" "+strconv.Itoa(int(seconds)))
+	return finishFn(t.Conn.Touch(key, seconds))
+}

library/cache/memcache/util.go

@@ -0,0 +1,32 @@
+package memcache
+
+import (
+	"github.com/gogo/protobuf/proto"
+)
+
+// RawItem item with FlagRAW flag.
+//
+// Expiration is the cache expiration time, in seconds: either a relative
+// time from now (up to 1 month), or an absolute Unix epoch time.
+// Zero means the Item has no expiration time.
+func RawItem(key string, data []byte, flags uint32, expiration int32) *Item {
+	return &Item{Key: key, Flags: flags | FlagRAW, Value: data, Expiration: expiration}
+}
+
+// JSONItem item with FlagJSON flag.
+//
+// Expiration is the cache expiration time, in seconds: either a relative
+// time from now (up to 1 month), or an absolute Unix epoch time.
+// Zero means the Item has no expiration time.
+func JSONItem(key string, v interface{}, flags uint32, expiration int32) *Item {
+	return &Item{Key: key, Flags: flags | FlagJSON, Object: v, Expiration: expiration}
+}
+
+// ProtobufItem item with FlagProtobuf flag.
+//
+// Expiration is the cache expiration time, in seconds: either a relative
+// time from now (up to 1 month), or an absolute Unix epoch time.
+// Zero means the Item has no expiration time.
+func ProtobufItem(key string, message proto.Message, flags uint32, expiration int32) *Item {
+	return &Item{Key: key, Flags: flags | FlagProtobuf, Object: message, Expiration: expiration}
+}

library/cache/memcache/util_test.go

@@ -0,0 +1,26 @@
+package memcache
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+
+	pb "go-common/library/cache/memcache/test"
+)
+
+func TestItemUtil(t *testing.T) {
+	item1 := RawItem("test", []byte("hh"), 0, 0)
+	assert.Equal(t, "test", item1.Key)
+	assert.Equal(t, []byte("hh"), item1.Value)
+	assert.Equal(t, FlagRAW, FlagRAW&item1.Flags)
+
+	item1 = JSONItem("test", &Item{}, 0, 0)
+	assert.Equal(t, "test", item1.Key)
+	assert.NotNil(t, item1.Object)
+	assert.Equal(t, FlagJSON, FlagJSON&item1.Flags)
+
+	item1 = ProtobufItem("test", &pb.TestItem{}, 0, 0)
+	assert.Equal(t, "test", item1.Key)
+	assert.NotNil(t, item1.Object)
+	assert.Equal(t, FlagProtobuf, FlagProtobuf&item1.Flags)
+}