Create & Init Project...

app/tool/cache/memcached/testdata/BUILD

@@ -0,0 +1,71 @@
+load(
+    "@io_bazel_rules_go//proto:def.bzl",
+    "go_proto_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_test",
+    "go_library",
+)
+
+proto_library(
+    name = "model_proto",
+    srcs = ["model.proto"],
+    tags = ["automanaged"],
+    deps = ["@gogo_special_proto//github.com/gogo/protobuf/gogoproto"],
+)
+
+go_proto_library(
+    name = "model_go_proto",
+    compilers = ["@io_bazel_rules_go//proto:gogofast_proto"],
+    importpath = "go-common/app/tool/cache/memcached/testdata",
+    proto = ":model_proto",
+    tags = ["automanaged"],
+    deps = ["@com_github_gogo_protobuf//gogoproto:go_default_library"],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["dao_test.go"],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "dao.go",
+        "mc.cache.go",
+    ],
+    embed = [":model_go_proto"],
+    importpath = "go-common/app/tool/cache/memcached/testdata",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//library/cache/memcache:go_default_library",
+        "//library/container/pool:go_default_library",
+        "//library/log:go_default_library",
+        "//library/stat/prom:go_default_library",
+        "//library/time:go_default_library",
+        "@com_github_gogo_protobuf//gogoproto:go_default_library",
+        "@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"],
+)

app/tool/cache/memcached/testdata/dao.go

@@ -0,0 +1,87 @@
+package testdata
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"go-common/library/cache/memcache"
+	"go-common/library/container/pool"
+	xtime "go-common/library/time"
+)
+
+// Dao .
+type Dao struct {
+	mc            *memcache.Pool
+	articleExpire int32
+}
+
+// New new dao
+func New() (d *Dao) {
+	cfg := &memcache.Config{
+		Config: &pool.Config{
+			Active:      10,
+			Idle:        5,
+			IdleTimeout: xtime.Duration(time.Second),
+		},
+		Name:  "test",
+		Proto: "tcp",
+		// Addr:         "172.16.33.54:11214",
+		Addr:         "127.0.0.1:11211",
+		DialTimeout:  xtime.Duration(time.Second),
+		ReadTimeout:  xtime.Duration(time.Second),
+		WriteTimeout: xtime.Duration(time.Second),
+	}
+	d = &Dao{
+		mc:            memcache.NewPool(cfg),
+		articleExpire: int32(5),
+	}
+	return
+}
+
+//go:generate $GOPATH/src/go-common/app/tool/cache/mc
+type _mc interface {
+	// mc: -key=articleKey
+	CacheArticles(c context.Context, keys []int64) (map[int64]*Article, error)
+	// mc: -key=articleKey
+	CacheArticle(c context.Context, key int64) (*Article, error)
+	// mc: -key=keyMid
+	CacheArticle1(c context.Context, key int64, mid int64) (*Article, error)
+	// mc: -key=noneKey
+	CacheNone(c context.Context) (*Article, error)
+	// mc: -key=articleKey
+	CacheString(c context.Context, key int64) (string, error)
+
+	// mc: -key=articleKey -expire=d.articleExpire -encode=json
+	AddCacheArticles(c context.Context, values map[int64]*Article) error
+	// 这里也支持自定义注释 会替换默认的注释
+	// mc: -key=articleKey -expire=d.articleExpire -encode=json|gzip
+	AddCacheArticle(c context.Context, key int64, value *Article) error
+	// mc: -key=keyMid -expire=d.articleExpire -encode=gob
+	AddCacheArticle1(c context.Context, key int64, value *Article, mid int64) error
+	// mc: -key=noneKey
+	AddCacheNone(c context.Context, value *Article) error
+	// mc: -key=articleKey -expire=d.articleExpire
+	AddCacheString(c context.Context, key int64, value string) error
+
+	// mc: -key=articleKey
+	DelCacheArticles(c context.Context, keys []int64) error
+	// mc: -key=articleKey
+	DelCacheArticle(c context.Context, key int64) error
+	// mc: -key=keyMid
+	DelCacheArticle1(c context.Context, key int64, mid int64) error
+	// mc: -key=noneKey
+	DelCacheNone(c context.Context) error
+}
+
+func articleKey(id int64) string {
+	return fmt.Sprintf("art_%d", id)
+}
+
+func keyMid(id, mid int64) string {
+	return fmt.Sprintf("art_%d_%d", id, mid)
+}
+
+func noneKey() string {
+	return "none"
+}

app/tool/cache/memcached/testdata/dao_test.go

@@ -0,0 +1,116 @@
+package testdata
+
+import (
+	"context"
+	"testing"
+)
+
+func TestArticle(t *testing.T) {
+	d := New()
+	c := context.TODO()
+	art := &Article{ID: 1, Title: "title"}
+	err := d.AddCacheArticle(c, art.ID, art)
+	if err != nil {
+		t.Errorf("err should be nil, get: %v", err)
+		t.FailNow()
+	}
+	art1, err := d.CacheArticle(c, art.ID)
+	if err != nil {
+		t.Errorf("err should be nil, get: %v", err)
+		t.FailNow()
+	}
+	if (art1.ID != art.ID) || (art.Title != art1.Title) {
+		t.Error("art not equal")
+		t.FailNow()
+	}
+	err = d.DelCacheArticle(c, art.ID)
+	if err != nil {
+		t.Errorf("err should be nil, get: %v", err)
+		t.FailNow()
+	}
+	art1, err = d.CacheArticle(c, art.ID)
+	if (art1 != nil) || (err != nil) {
+		t.Errorf("art %v, err: %v", art1, err)
+		t.FailNow()
+	}
+}
+
+func TestNone(t *testing.T) {
+	d := New()
+	c := context.TODO()
+	art := &Article{ID: 1, Title: "title"}
+	err := d.AddCacheNone(c, art)
+	if err != nil {
+		t.Errorf("err should be nil, get: %v", err)
+		t.FailNow()
+	}
+	art1, err := d.CacheNone(c)
+	if err != nil {
+		t.Errorf("err should be nil, get: %v", err)
+		t.FailNow()
+	}
+	if (art1.ID != art.ID) || (art.Title != art1.Title) {
+		t.Error("art not equal")
+		t.FailNow()
+	}
+	err = d.DelCacheNone(c)
+	if err != nil {
+		t.Errorf("err should be nil, get: %v", err)
+		t.FailNow()
+	}
+	art1, err = d.CacheNone(c)
+	if (art1 != nil) || (err != nil) {
+		t.Errorf("art %v, err: %v", art1, err)
+		t.FailNow()
+	}
+}
+
+func TestArticles(t *testing.T) {
+	d := New()
+	c := context.TODO()
+	art1 := &Article{ID: 1, Title: "title"}
+	art2 := &Article{ID: 2, Title: "title"}
+	err := d.AddCacheArticles(c, map[int64]*Article{1: art1, 2: art2})
+	if err != nil {
+		t.Errorf("err should be nil, get: %v", err)
+		t.FailNow()
+	}
+	arts, err := d.CacheArticles(c, []int64{art1.ID, art2.ID})
+	if err != nil {
+		t.Errorf("err should be nil, get: %v", err)
+		t.FailNow()
+	}
+	if (arts[1].Title != art1.Title) || (arts[2].Title != art2.Title) {
+		t.Error("art not equal")
+		t.FailNow()
+	}
+	err = d.DelCacheArticles(c, []int64{art1.ID, art2.ID})
+	if err != nil {
+		t.Errorf("err should be nil, get: %v", err)
+		t.FailNow()
+	}
+	arts, err = d.CacheArticles(c, []int64{art1.ID, art2.ID})
+	if (arts != nil) || (err != nil) {
+		t.Errorf("art %v, err: %v", art1, err)
+		t.FailNow()
+	}
+}
+
+func TestString(t *testing.T) {
+	d := New()
+	c := context.TODO()
+	err := d.AddCacheString(c, 1, "abc")
+	if err != nil {
+		t.Errorf("err should be nil, get: %v", err)
+		t.FailNow()
+	}
+	res, err := d.CacheString(c, 1)
+	if err != nil {
+		t.Errorf("err should be nil, get: %v", err)
+		t.FailNow()
+	}
+	if res != "abc" {
+		t.Error("res wrong")
+		t.FailNow()
+	}
+}

app/tool/cache/memcached/testdata/mc.cache.go

@@ -0,0 +1,350 @@
+// Code generated by $GOPATH/src/go-common/app/tool/cache/mc. DO NOT EDIT.
+
+/*
+  Package testdata is a generated mc cache package.
+  It is generated from:
+  type _mc interface {
+		// mc: -key=articleKey
+		CacheArticles(c context.Context, keys []int64) (map[int64]*Article, error)
+		// mc: -key=articleKey
+		CacheArticle(c context.Context, key int64) (*Article, error)
+		// mc: -key=keyMid
+		CacheArticle1(c context.Context, key int64, mid int64) (*Article, error)
+		// mc: -key=noneKey
+		CacheNone(c context.Context) (*Article, error)
+		// mc: -key=articleKey
+		CacheString(c context.Context, key int64) (string, error)
+
+		// mc: -key=articleKey -expire=d.articleExpire -encode=json
+		AddCacheArticles(c context.Context, values map[int64]*Article) error
+		// 这里也支持自定义注释 会替换默认的注释
+		// mc: -key=articleKey -expire=d.articleExpire -encode=json|gzip
+		AddCacheArticle(c context.Context, key int64, value *Article) error
+		// mc: -key=keyMid -expire=d.articleExpire -encode=gob
+		AddCacheArticle1(c context.Context, key int64, value *Article, mid int64) error
+		// mc: -key=noneKey
+		AddCacheNone(c context.Context, value *Article) error
+		// mc: -key=articleKey -expire=d.articleExpire
+		AddCacheString(c context.Context, key int64, value string) error
+
+		// mc: -key=articleKey
+		DelCacheArticles(c context.Context, keys []int64) error
+		// mc: -key=articleKey
+		DelCacheArticle(c context.Context, key int64) error
+		// mc: -key=keyMid
+		DelCacheArticle1(c context.Context, key int64, mid int64) error
+		// mc: -key=noneKey
+		DelCacheNone(c context.Context) error
+	}
+*/
+
+package testdata
+
+import (
+	"context"
+	"fmt"
+
+	"go-common/library/cache/memcache"
+	"go-common/library/log"
+	"go-common/library/stat/prom"
+)
+
+var _ _mc
+
+// CacheArticles get data from mc
+func (d *Dao) CacheArticles(c context.Context, ids []int64) (res map[int64]*Article, err error) {
+	l := len(ids)
+	if l == 0 {
+		return
+	}
+	keysMap := make(map[string]int64, l)
+	keys := make([]string, 0, l)
+	for _, id := range ids {
+		key := articleKey(id)
+		keysMap[key] = id
+		keys = append(keys, key)
+	}
+	conn := d.mc.Get(c)
+	defer conn.Close()
+	replies, err := conn.GetMulti(keys)
+	if err != nil {
+		prom.BusinessErrCount.Incr("mc:CacheArticles")
+		log.Errorv(c, log.KV("CacheArticles", fmt.Sprintf("%+v", err)), log.KV("keys", keys))
+		return
+	}
+	for key, reply := range replies {
+		var v *Article
+		v = &Article{}
+		err = conn.Scan(reply, v)
+		if err != nil {
+			prom.BusinessErrCount.Incr("mc:CacheArticles")
+			log.Errorv(c, log.KV("CacheArticles", fmt.Sprintf("%+v", err)), log.KV("key", key))
+			return
+		}
+		if res == nil {
+			res = make(map[int64]*Article, len(keys))
+		}
+		res[keysMap[key]] = v
+	}
+	return
+}
+
+// CacheArticle get data from mc
+func (d *Dao) CacheArticle(c context.Context, id int64) (res *Article, err error) {
+	conn := d.mc.Get(c)
+	defer conn.Close()
+	key := articleKey(id)
+	reply, err := conn.Get(key)
+	if err != nil {
+		if err == memcache.ErrNotFound {
+			err = nil
+			return
+		}
+		prom.BusinessErrCount.Incr("mc:CacheArticle")
+		log.Errorv(c, log.KV("CacheArticle", fmt.Sprintf("%+v", err)), log.KV("key", key))
+		return
+	}
+	res = &Article{}
+	err = conn.Scan(reply, res)
+	if err != nil {
+		prom.BusinessErrCount.Incr("mc:CacheArticle")
+		log.Errorv(c, log.KV("CacheArticle", fmt.Sprintf("%+v", err)), log.KV("key", key))
+		return
+	}
+	return
+}
+
+// CacheArticle1 get data from mc
+func (d *Dao) CacheArticle1(c context.Context, id int64, mid int64) (res *Article, err error) {
+	conn := d.mc.Get(c)
+	defer conn.Close()
+	key := keyMid(id, mid)
+	reply, err := conn.Get(key)
+	if err != nil {
+		if err == memcache.ErrNotFound {
+			err = nil
+			return
+		}
+		prom.BusinessErrCount.Incr("mc:CacheArticle1")
+		log.Errorv(c, log.KV("CacheArticle1", fmt.Sprintf("%+v", err)), log.KV("key", key))
+		return
+	}
+	res = &Article{}
+	err = conn.Scan(reply, res)
+	if err != nil {
+		prom.BusinessErrCount.Incr("mc:CacheArticle1")
+		log.Errorv(c, log.KV("CacheArticle1", fmt.Sprintf("%+v", err)), log.KV("key", key))
+		return
+	}
+	return
+}
+
+// CacheNone get data from mc
+func (d *Dao) CacheNone(c context.Context) (res *Article, err error) {
+	conn := d.mc.Get(c)
+	defer conn.Close()
+	key := noneKey()
+	reply, err := conn.Get(key)
+	if err != nil {
+		if err == memcache.ErrNotFound {
+			err = nil
+			return
+		}
+		prom.BusinessErrCount.Incr("mc:CacheNone")
+		log.Errorv(c, log.KV("CacheNone", fmt.Sprintf("%+v", err)), log.KV("key", key))
+		return
+	}
+	res = &Article{}
+	err = conn.Scan(reply, res)
+	if err != nil {
+		prom.BusinessErrCount.Incr("mc:CacheNone")
+		log.Errorv(c, log.KV("CacheNone", fmt.Sprintf("%+v", err)), log.KV("key", key))
+		return
+	}
+	return
+}
+
+// CacheString get data from mc
+func (d *Dao) CacheString(c context.Context, id int64) (res string, err error) {
+	conn := d.mc.Get(c)
+	defer conn.Close()
+	key := articleKey(id)
+	reply, err := conn.Get(key)
+	if err != nil {
+		if err == memcache.ErrNotFound {
+			err = nil
+			return
+		}
+		prom.BusinessErrCount.Incr("mc:CacheString")
+		log.Errorv(c, log.KV("CacheString", fmt.Sprintf("%+v", err)), log.KV("key", key))
+		return
+	}
+	err = conn.Scan(reply, &res)
+	if err != nil {
+		prom.BusinessErrCount.Incr("mc:CacheString")
+		log.Errorv(c, log.KV("CacheString", fmt.Sprintf("%+v", err)), log.KV("key", key))
+		return
+	}
+	return
+}
+
+// AddCacheArticles Set data to mc
+func (d *Dao) AddCacheArticles(c context.Context, values map[int64]*Article) (err error) {
+	if len(values) == 0 {
+		return
+	}
+	conn := d.mc.Get(c)
+	defer conn.Close()
+	for id, val := range values {
+		key := articleKey(id)
+		item := &memcache.Item{Key: key, Object: val, Expiration: d.articleExpire, Flags: memcache.FlagJSON}
+		if err = conn.Set(item); err != nil {
+			prom.BusinessErrCount.Incr("mc:AddCacheArticles")
+			log.Errorv(c, log.KV("AddCacheArticles", fmt.Sprintf("%+v", err)), log.KV("key", key))
+			return
+		}
+	}
+	return
+}
+
+// AddCacheArticle 这里也支持自定义注释 会替换默认的注释
+func (d *Dao) AddCacheArticle(c context.Context, id int64, val *Article) (err error) {
+	if val == nil {
+		return
+	}
+	conn := d.mc.Get(c)
+	defer conn.Close()
+	key := articleKey(id)
+	item := &memcache.Item{Key: key, Object: val, Expiration: d.articleExpire, Flags: memcache.FlagJSON | memcache.FlagGzip}
+	if err = conn.Set(item); err != nil {
+		prom.BusinessErrCount.Incr("mc:AddCacheArticle")
+		log.Errorv(c, log.KV("AddCacheArticle", fmt.Sprintf("%+v", err)), log.KV("key", key))
+		return
+	}
+	return
+}
+
+// AddCacheArticle1 Set data to mc
+func (d *Dao) AddCacheArticle1(c context.Context, id int64, val *Article, mid int64) (err error) {
+	if val == nil {
+		return
+	}
+	conn := d.mc.Get(c)
+	defer conn.Close()
+	key := keyMid(id, mid)
+	item := &memcache.Item{Key: key, Object: val, Expiration: d.articleExpire, Flags: memcache.FlagGOB}
+	if err = conn.Set(item); err != nil {
+		prom.BusinessErrCount.Incr("mc:AddCacheArticle1")
+		log.Errorv(c, log.KV("AddCacheArticle1", fmt.Sprintf("%+v", err)), log.KV("key", key))
+		return
+	}
+	return
+}
+
+// AddCacheNone Set data to mc
+func (d *Dao) AddCacheNone(c context.Context, val *Article) (err error) {
+	if val == nil {
+		return
+	}
+	conn := d.mc.Get(c)
+	defer conn.Close()
+	key := noneKey()
+	item := &memcache.Item{Key: key, Object: val, Expiration: d.articleExpire, Flags: memcache.FlagJSON}
+	if err = conn.Set(item); err != nil {
+		prom.BusinessErrCount.Incr("mc:AddCacheNone")
+		log.Errorv(c, log.KV("AddCacheNone", fmt.Sprintf("%+v", err)), log.KV("key", key))
+		return
+	}
+	return
+}
+
+// AddCacheString Set data to mc
+func (d *Dao) AddCacheString(c context.Context, id int64, val string) (err error) {
+	if len(val) == 0 {
+		return
+	}
+	conn := d.mc.Get(c)
+	defer conn.Close()
+	key := articleKey(id)
+	bs := []byte(val)
+	item := &memcache.Item{Key: key, Value: bs, Expiration: d.articleExpire, Flags: memcache.FlagRAW}
+	if err = conn.Set(item); err != nil {
+		prom.BusinessErrCount.Incr("mc:AddCacheString")
+		log.Errorv(c, log.KV("AddCacheString", fmt.Sprintf("%+v", err)), log.KV("key", key))
+		return
+	}
+	return
+}
+
+// DelCacheArticles delete data from mc
+func (d *Dao) DelCacheArticles(c context.Context, ids []int64) (err error) {
+	if len(ids) == 0 {
+		return
+	}
+	conn := d.mc.Get(c)
+	defer conn.Close()
+	for _, id := range ids {
+		key := articleKey(id)
+		if err = conn.Delete(key); err != nil {
+			if err == memcache.ErrNotFound {
+				err = nil
+				continue
+			}
+			prom.BusinessErrCount.Incr("mc:DelCacheArticles")
+			log.Errorv(c, log.KV("DelCacheArticles", fmt.Sprintf("%+v", err)), log.KV("key", key))
+			return
+		}
+	}
+	return
+}
+
+// DelCacheArticle delete data from mc
+func (d *Dao) DelCacheArticle(c context.Context, id int64) (err error) {
+	conn := d.mc.Get(c)
+	defer conn.Close()
+	key := articleKey(id)
+	if err = conn.Delete(key); err != nil {
+		if err == memcache.ErrNotFound {
+			err = nil
+			return
+		}
+		prom.BusinessErrCount.Incr("mc:DelCacheArticle")
+		log.Errorv(c, log.KV("DelCacheArticle", fmt.Sprintf("%+v", err)), log.KV("key", key))
+		return
+	}
+	return
+}
+
+// DelCacheArticle1 delete data from mc
+func (d *Dao) DelCacheArticle1(c context.Context, id int64, mid int64) (err error) {
+	conn := d.mc.Get(c)
+	defer conn.Close()
+	key := keyMid(id, mid)
+	if err = conn.Delete(key); err != nil {
+		if err == memcache.ErrNotFound {
+			err = nil
+			return
+		}
+		prom.BusinessErrCount.Incr("mc:DelCacheArticle1")
+		log.Errorv(c, log.KV("DelCacheArticle1", fmt.Sprintf("%+v", err)), log.KV("key", key))
+		return
+	}
+	return
+}
+
+// DelCacheNone delete data from mc
+func (d *Dao) DelCacheNone(c context.Context) (err error) {
+	conn := d.mc.Get(c)
+	defer conn.Close()
+	key := noneKey()
+	if err = conn.Delete(key); err != nil {
+		if err == memcache.ErrNotFound {
+			err = nil
+			return
+		}
+		prom.BusinessErrCount.Incr("mc:DelCacheNone")
+		log.Errorv(c, log.KV("DelCacheNone", fmt.Sprintf("%+v", err)), log.KV("key", key))
+		return
+	}
+	return
+}

app/tool/cache/memcached/testdata/model.pb.go

@@ -0,0 +1,328 @@
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
+// source: model.proto
+
+/*
+	Package model is a generated protocol buffer package.
+
+	It is generated from these files:
+		model.proto
+
+	It has these top-level messages:
+		Article
+*/
+package testdata
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+import _ "github.com/gogo/protobuf/gogoproto"
+
+import io "io"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.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 _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
+
+type Article struct {
+	ID    int64  `protobuf:"varint,1,opt,name=ID,proto3" json:"id"`
+	Title string `protobuf:"bytes,3,opt,name=Title,proto3" json:"title"`
+}
+
+func (m *Article) Reset()                    { *m = Article{} }
+func (m *Article) String() string            { return proto.CompactTextString(m) }
+func (*Article) ProtoMessage()               {}
+func (*Article) Descriptor() ([]byte, []int) { return fileDescriptorModel, []int{0} }
+
+func init() {
+	proto.RegisterType((*Article)(nil), "model.Article")
+}
+func (m *Article) 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 *Article) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if m.ID != 0 {
+		dAtA[i] = 0x8
+		i++
+		i = encodeVarintModel(dAtA, i, uint64(m.ID))
+	}
+	if len(m.Title) > 0 {
+		dAtA[i] = 0x1a
+		i++
+		i = encodeVarintModel(dAtA, i, uint64(len(m.Title)))
+		i += copy(dAtA[i:], m.Title)
+	}
+	return i, nil
+}
+
+func encodeVarintModel(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 *Article) Size() (n int) {
+	var l int
+	_ = l
+	if m.ID != 0 {
+		n += 1 + sovModel(uint64(m.ID))
+	}
+	l = len(m.Title)
+	if l > 0 {
+		n += 1 + l + sovModel(uint64(l))
+	}
+	return n
+}
+
+func sovModel(x uint64) (n int) {
+	for {
+		n++
+		x >>= 7
+		if x == 0 {
+			break
+		}
+	}
+	return n
+}
+func sozModel(x uint64) (n int) {
+	return sovModel(uint64((x << 1) ^ uint64((int64(x) >> 63))))
+}
+func (m *Article) 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 ErrIntOverflowModel
+			}
+			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: Article: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: Article: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
+			}
+			m.ID = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowModel
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.ID |= (int64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Title", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowModel
+				}
+				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 ErrInvalidLengthModel
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Title = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipModel(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthModel
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func skipModel(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, ErrIntOverflowModel
+			}
+			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, ErrIntOverflowModel
+				}
+				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, ErrIntOverflowModel
+				}
+				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, ErrInvalidLengthModel
+			}
+			return iNdEx, nil
+		case 3:
+			for {
+				var innerWire uint64
+				var start int = iNdEx
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return 0, ErrIntOverflowModel
+					}
+					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 := skipModel(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 (
+	ErrInvalidLengthModel = fmt.Errorf("proto: negative length found during unmarshaling")
+	ErrIntOverflowModel   = fmt.Errorf("proto: integer overflow")
+)
+
+func init() { proto.RegisterFile("model.proto", fileDescriptorModel) }
+
+var fileDescriptorModel = []byte{
+	// 166 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xe2, 0xce, 0xcd, 0x4f, 0x49,
+	0xcd, 0xd1, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x62, 0x05, 0x73, 0xa4, 0x74, 0xd3, 0x33, 0x4b,
+	0x32, 0x4a, 0x93, 0xf4, 0x92, 0xf3, 0x73, 0xf5, 0xd3, 0xf3, 0xd3, 0xf3, 0xf5, 0xc1, 0xb2, 0x49,
+	0xa5, 0x69, 0x60, 0x1e, 0x98, 0x03, 0x66, 0x41, 0x74, 0x29, 0x39, 0x71, 0xb1, 0x3b, 0x16, 0x95,
+	0x64, 0x26, 0xe7, 0xa4, 0x0a, 0x89, 0x71, 0x31, 0x79, 0xba, 0x48, 0x30, 0x2a, 0x30, 0x6a, 0x30,
+	0x3b, 0xb1, 0xbd, 0xba, 0x27, 0xcf, 0x94, 0x99, 0x12, 0xc4, 0xe4, 0xe9, 0x22, 0x24, 0xcf, 0xc5,
+	0x1a, 0x92, 0x59, 0x92, 0x93, 0x2a, 0xc1, 0xac, 0xc0, 0xa8, 0xc1, 0xe9, 0xc4, 0xf9, 0xea, 0x9e,
+	0x3c, 0x6b, 0x09, 0x48, 0x20, 0x08, 0x22, 0xee, 0x24, 0x71, 0xe2, 0xa1, 0x1c, 0xc3, 0x85, 0x87,
+	0x72, 0x0c, 0x27, 0x1e, 0xc9, 0x31, 0x5e, 0x78, 0x24, 0xc7, 0xf8, 0xe0, 0x91, 0x1c, 0xe3, 0x8c,
+	0xc7, 0x72, 0x0c, 0x49, 0x6c, 0x60, 0x4b, 0x8c, 0x01, 0x01, 0x00, 0x00, 0xff, 0xff, 0x11, 0xa6,
+	0xfa, 0x1c, 0xa9, 0x00, 0x00, 0x00,
+}

app/tool/cache/memcached/testdata/model.proto

@@ -0,0 +1,14 @@
+syntax = "proto3";
+package model;
+import "github.com/gogo/protobuf/gogoproto/gogo.proto";
+
+option (gogoproto.goproto_enum_prefix_all) = false;
+option (gogoproto.goproto_getters_all) = false;
+option (gogoproto.unmarshaler_all) = true;
+option (gogoproto.marshaler_all) = true;
+option (gogoproto.sizer_all) = true;
+
+message Article {
+    int64 ID = 1 [(gogoproto.jsontag) = "id"];
+    string Title = 3 [(gogoproto.jsontag) = "title"];
+}