Create & Init Project...

app/interface/main/tv/dao/upper/BUILD

@@ -0,0 +1,57 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_test",
+    "go_library",
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = [
+        "dao_test.go",
+        "load_upper_test.go",
+    ],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/tv/conf:go_default_library",
+        "//app/interface/main/tv/model/upper:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "dao.go",
+        "load_upper.go",
+    ],
+    importpath = "go-common/app/interface/main/tv/dao/upper",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/interface/main/tv/conf:go_default_library",
+        "//app/interface/main/tv/model/upper:go_default_library",
+        "//library/cache/memcache:go_default_library",
+        "//library/database/sql:go_default_library",
+        "//library/ecode:go_default_library",
+        "//library/log:go_default_library",
+        "//library/stat/prom: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/interface/main/tv/dao/upper/dao.go

@@ -0,0 +1,56 @@
+package upper
+
+import (
+	"runtime"
+	"time"
+
+	"go-common/app/interface/main/tv/conf"
+	"go-common/library/cache/memcache"
+	"go-common/library/database/sql"
+	"go-common/library/log"
+	"go-common/library/stat/prom"
+)
+
+var (
+	missedCount = prom.CacheMiss
+	cachedCount = prom.CacheHit
+)
+
+// Dao is account dao.
+type Dao struct {
+	mc       *memcache.Pool
+	mcExpire int32
+	DB       *sql.DB
+	mCh      chan func()
+}
+
+// New account dao.
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		mc:       memcache.NewPool(c.Memcache.Config),
+		mcExpire: int32(time.Duration(c.Memcache.CmsExpire) / time.Second),
+		DB:       sql.NewMySQL(c.Mysql),
+		mCh:      make(chan func(), 10240),
+	}
+	for i := 0; i < runtime.NumCPU()*2; i++ {
+		go d.cacheproc()
+	}
+	return
+}
+
+// addCache add archive to mc or redis
+func (d *Dao) addCache(f func()) {
+	select {
+	case d.mCh <- f:
+	default:
+		log.Warn("cacheproc chan full")
+	}
+}
+
+// cacheproc write memcache and stat redis use goroutine
+func (d *Dao) cacheproc() {
+	for {
+		f := <-d.mCh
+		f()
+	}
+}

app/interface/main/tv/dao/upper/dao_test.go

@@ -0,0 +1,41 @@
+package upper
+
+import (
+	"context"
+	"flag"
+	"fmt"
+	"path/filepath"
+	"testing"
+
+	"go-common/app/interface/main/tv/conf"
+
+	"encoding/json"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+var (
+	ctx = context.TODO()
+	d   *Dao
+)
+
+func WithDao(f func(d *Dao)) func() {
+	return func() {
+		dir, _ := filepath.Abs("../../cmd/tv-interface.toml")
+		flag.Set("conf", dir)
+		conf.Init()
+		if d == nil {
+			d = New(conf.Conf)
+		}
+		f(d)
+	}
+}
+
+func TestDao_LoadUpMeta(t *testing.T) {
+	Convey("TestDao_LoadUpMeta", t, WithDao(func(d *Dao) {
+		res, err := d.LoadUpMeta(ctx, 27515256)
+		So(err, ShouldBeNil)
+		data, _ := json.Marshal(res)
+		fmt.Println(string(data))
+	}))
+}

app/interface/main/tv/dao/upper/load_upper.go

@@ -0,0 +1,108 @@
+package upper
+
+import (
+	"context"
+	"database/sql"
+	"fmt"
+
+	upMdl "go-common/app/interface/main/tv/model/upper"
+	"go-common/library/cache/memcache"
+	xsql "go-common/library/database/sql"
+	"go-common/library/ecode"
+	"go-common/library/log"
+)
+
+const (
+	_loadUpper = "SELECT id,mid,toinit,submit,ori_name,cms_name,ori_face,cms_face,valid,deleted FROM ugc_uploader WHERE mid = ?"
+)
+
+func upperMetaKey(MID int64) string {
+	return fmt.Sprintf("up_cms_%d", MID)
+}
+
+// LoadUpMeta loads the upper meta cms data from cache, for missed ones, pick them from the DB
+func (d *Dao) LoadUpMeta(ctx context.Context, mid int64) (upper *upMdl.Upper, err error) {
+	if upper, err = d.upMetaCache(ctx, mid); err != nil { // mc error
+		log.Error("LoadUpMeta Get Mid [%d] from CMS Error (%v)", mid, err)
+		return
+	}
+	if upper != nil { // mc found
+		return
+	}
+	if upper, err = d.upMetaDB(ctx, mid); err != nil { // db error
+		log.Error("LoadUpMeta Get Mid ERROR (%d) (%v)", mid, err)
+		return
+	}
+	if upper == nil { // db not found
+		err = ecode.NothingFound
+		return
+	}
+	d.addUpMetaCache(upper) // db found, re-fill the cache
+	return
+}
+
+// upMetaCache get upper meta cache.
+func (d *Dao) upMetaCache(c context.Context, mid int64) (upper *upMdl.Upper, err error) {
+	var (
+		key  = upperMetaKey(mid)
+		conn = d.mc.Get(c)
+		item *memcache.Item
+	)
+	defer conn.Close()
+	if item, err = conn.Get(key); err != nil {
+		if err == memcache.ErrNotFound {
+			err = nil
+			missedCount.Add("tv-meta", 1)
+		} else {
+			log.Error("conn.Get(%s) error(%v)", key, err)
+		}
+		return
+	}
+	if err = conn.Scan(item, &upper); err != nil {
+		log.Error("conn.Get(%s) error(%v)", key, err)
+	}
+	cachedCount.Add("tv-meta", 1)
+	return
+}
+
+// upMetaDB gets upper meta info from DB
+func (d *Dao) upMetaDB(c context.Context, mid int64) (upper *upMdl.Upper, err error) {
+	var row *xsql.Row
+	if row = d.DB.QueryRow(c, _loadUpper, mid); err != nil {
+		log.Error("d.db.QueryRow(%d) error(%v)", mid, err)
+		return
+	}
+	upper = &upMdl.Upper{}
+	// "SELECT id,mid,to_init,submit,ori_name,cms_name,ori_face,cms_face,valid,deleted FROM ugc_uploader WHERE mid = ?"
+	if err = row.Scan(&upper.ID, &upper.MID, &upper.Toinit, &upper.Submit, &upper.OriName,
+		&upper.CMSName, &upper.OriFace, &upper.CMSFace, &upper.Valid, &upper.Deleted); err != nil {
+		if err == sql.ErrNoRows {
+			err = nil
+			upper = nil
+		} else {
+			log.Error("row.Scan(mid %d) error(%v)", mid, err)
+		}
+	}
+	return
+}
+
+// setUpMetaCache save upMdl.Upper to memcache
+func (d *Dao) setUpMetaCache(c context.Context, upper *upMdl.Upper) (err error) {
+	var (
+		key  = upperMetaKey(upper.MID)
+		conn = d.mc.Get(c)
+	)
+	defer conn.Close()
+	if err = conn.Set(&memcache.Item{Key: key, Object: upper, Flags: memcache.FlagJSON, Expiration: d.mcExpire}); err != nil {
+		log.Error("conn.Set error(%v)", err)
+		return
+	}
+	return
+}
+
+// addUpMetaCache add upper meta cache
+func (d *Dao) addUpMetaCache(upper *upMdl.Upper) {
+	d.addCache(func() {
+		d.setUpMetaCache(context.TODO(), upper)
+	})
+}

app/interface/main/tv/dao/upper/load_upper_test.go

@@ -0,0 +1,87 @@
+package upper
+
+import (
+	"context"
+	upMdl "go-common/app/interface/main/tv/model/upper"
+	"testing"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestUpperupperMetaKey(t *testing.T) {
+	var (
+		MID = int64(0)
+	)
+	convey.Convey("upperMetaKey", t, func(c convey.C) {
+		p1 := upperMetaKey(MID)
+		c.Convey("Then p1 should not be nil.", func(c convey.C) {
+			c.So(p1, convey.ShouldNotBeNil)
+		})
+	})
+}
+
+func TestUpperLoadUpMeta(t *testing.T) {
+	var (
+		ctx = context.Background()
+		mid = int64(0)
+	)
+	convey.Convey("LoadUpMeta", t, func(c convey.C) {
+		upper, err := d.LoadUpMeta(ctx, mid)
+		c.Convey("Then err should be nil.upper should not be nil.", func(c convey.C) {
+			c.So(err, convey.ShouldBeNil)
+			c.So(upper, convey.ShouldNotBeNil)
+		})
+	})
+}
+
+func TestUpperupMetaCache(t *testing.T) {
+	var (
+		ctx = context.Background()
+		mid = int64(0)
+	)
+	convey.Convey("upMetaCache", t, func(c convey.C) {
+		upper, err := d.upMetaCache(ctx, mid)
+		c.Convey("Then err should be nil.upper should not be nil.", func(c convey.C) {
+			c.So(err, convey.ShouldBeNil)
+			c.So(upper, convey.ShouldNotBeNil)
+		})
+	})
+}
+
+func TestUpperupMetaDB(t *testing.T) {
+	var (
+		ctx = context.Background()
+		mid = int64(0)
+	)
+	convey.Convey("upMetaDB", t, func(c convey.C) {
+		upper, err := d.upMetaDB(ctx, mid)
+		c.Convey("Then err should be nil.upper should not be nil.", func(c convey.C) {
+			c.So(err, convey.ShouldBeNil)
+			c.So(upper, convey.ShouldNotBeNil)
+		})
+	})
+}
+
+func TestUppersetUpMetaCache(t *testing.T) {
+	var (
+		ctx   = context.Background()
+		upper = &upMdl.Upper{}
+	)
+	convey.Convey("setUpMetaCache", t, func(c convey.C) {
+		err := d.setUpMetaCache(ctx, upper)
+		c.Convey("Then err should be nil.", func(c convey.C) {
+			c.So(err, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestUpperaddUpMetaCache(t *testing.T) {
+	var (
+		upper = &upMdl.Upper{}
+	)
+	convey.Convey("addUpMetaCache", t, func(c convey.C) {
+		d.addUpMetaCache(upper)
+		c.Convey("No return values", func(c convey.C) {
+		})
+	})
+}