Create & Init Project...

app/interface/main/app-feed/dao/archive/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",
+        "memcache_test.go",
+    ],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/app-feed/conf:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "dao.go",
+        "memcache.go",
+    ],
+    importpath = "go-common/app/interface/main/app-feed/dao/archive",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/app-feed/conf:go_default_library",
+        "//app/service/main/archive/api:go_default_library",
+        "//app/service/main/archive/api/gorpc:go_default_library",
+        "//app/service/main/archive/model/archive:go_default_library",
+        "//library/cache/memcache:go_default_library",
+        "//library/log:go_default_library",
+        "//library/net/metadata:go_default_library",
+        "//library/sync/errgroup:go_default_library",
+        "//vendor/github.com/pkg/errors: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/app-feed/dao/archive/dao.go

@@ -0,0 +1,119 @@
+package archive
+
+import (
+	"context"
+	"time"
+
+	"go-common/app/interface/main/app-feed/conf"
+	"go-common/app/service/main/archive/api"
+	arcrpc "go-common/app/service/main/archive/api/gorpc"
+	"go-common/app/service/main/archive/model/archive"
+	"go-common/library/cache/memcache"
+	"go-common/library/log"
+	"go-common/library/net/metadata"
+	"go-common/library/sync/errgroup"
+
+	"github.com/pkg/errors"
+)
+
+// Dao is archive dao.
+type Dao struct {
+	// rpc
+	arcRPC *arcrpc.Service2
+	// mc
+	mc       *memcache.Pool
+	expireMc int32
+}
+
+// New new a archive dao.
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		// rpc
+		arcRPC: arcrpc.New2(c.ArchiveRPC),
+		// mc
+		mc:       memcache.NewPool(c.Memcache.Feed.Config),
+		expireMc: int32(time.Duration(c.Memcache.Feed.ExpireArchive) / time.Second),
+	}
+	return
+}
+
+func (d *Dao) PingMC(c context.Context) (err error) {
+	conn := d.mc.Get(c)
+	item := &memcache.Item{Key: "ping", Value: []byte{1}, Flags: memcache.FlagRAW, Expiration: d.expireMc}
+	err = conn.Set(item)
+	conn.Close()
+	return
+}
+
+// Archives multi get archives.
+func (d *Dao) Archives(c context.Context, aids []int64) (am map[int64]*api.Arc, err error) {
+	if len(aids) == 0 {
+		return
+	}
+	g, ctx := errgroup.WithContext(c)
+	g.Go(func() (err error) {
+		var missed []int64
+		if am, missed, err = d.arcsCache(ctx, aids); err != nil {
+			missed = aids
+			log.Error("%+v", err)
+			err = nil
+		}
+		if len(missed) == 0 {
+			return
+		}
+		var tmp map[int64]*api.Arc
+		arg := &archive.ArgAids2{Aids: missed}
+		if tmp, err = d.arcRPC.Archives3(c, arg); err != nil {
+			err = errors.Wrapf(err, "%v", arg)
+			return
+		}
+		for aid, a := range tmp {
+			am[aid] = a
+		}
+		return
+	})
+	var stm map[int64]*api.Stat
+	g.Go(func() (err error) {
+		var missed []int64
+		if stm, missed, err = d.statsCache(ctx, aids); err != nil {
+			missed = aids
+			log.Error("%+v", err)
+			err = nil
+		}
+		if len(missed) == 0 {
+			return
+		}
+		tmp, err := d.arcRPC.Stats3(ctx, &archive.ArgAids2{Aids: missed})
+		if err != nil {
+			log.Error("%+v", err)
+			err = nil
+			return
+		}
+		for _, st := range tmp {
+			stm[st.Aid] = st
+		}
+		return
+	})
+	if err = g.Wait(); err != nil {
+		return
+	}
+	for aid, arc := range am {
+		if st, ok := stm[aid]; ok {
+			arc.Stat = *st
+		}
+	}
+	return
+}
+
+// ArchivesWithPlayer archives witch player
+func (d *Dao) ArchivesWithPlayer(c context.Context, aids []int64, qn int, platform string, fnver, fnval, forceHost, build int) (res map[int64]*archive.ArchiveWithPlayer, err error) {
+	if len(aids) == 0 {
+		return
+	}
+	ip := metadata.String(c, metadata.RemoteIP)
+	arg := &archive.ArgPlayer{Aids: aids, Qn: qn, Platform: platform, Fnval: fnval, Fnver: fnver, RealIP: ip, ForceHost: forceHost, Build: build}
+	if res, err = d.arcRPC.ArchivesWithPlayer(c, arg); err != nil {
+		err = errors.Wrapf(err, "%v", arg)
+	}
+	return
+}

app/interface/main/app-feed/dao/archive/dao_test.go

@@ -0,0 +1,77 @@
+package archive
+
+import (
+	"context"
+	"flag"
+	"os"
+	"testing"
+
+	"go-common/app/interface/main/app-feed/conf"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+var (
+	d *Dao
+)
+
+func TestMain(m *testing.M) {
+	if os.Getenv("DEPLOY_ENV") != "" {
+		flag.Set("app_id", "main.app-svr.app-feed")
+		flag.Set("conf_token", "OC30xxkAOyaH9fI6FRuXA0Ob5HL0f3kc")
+		flag.Set("tree_id", "2686")
+		flag.Set("conf_version", "docker-1")
+		flag.Set("deploy_env", "uat")
+		flag.Set("conf_host", "config.bilibili.co")
+		flag.Set("conf_path", "/tmp")
+		flag.Set("region", "sh")
+		flag.Set("zone", "sh001")
+	}
+	flag.Parse()
+	if err := conf.Init(); err != nil {
+		panic(err)
+	}
+	d = New(conf.Conf)
+	m.Run()
+	os.Exit(0)
+}
+
+func TestPing(t *testing.T) {
+	var (
+		c = context.TODO()
+	)
+	convey.Convey("Ping", t, func(ctx convey.C) {
+		d.PingMC(c)
+	})
+}
+
+func TestArchives(t *testing.T) {
+	var (
+		c    = context.TODO()
+		aids = []int64{1}
+	)
+	convey.Convey("Ping", t, func(ctx convey.C) {
+		_, err := d.Archives(c, aids)
+		ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestArchivesWithPlayer(t *testing.T) {
+	var (
+		c         = context.TODO()
+		aids      = []int64{1}
+		qn        = 32
+		platform  = "android"
+		fnver     = 0
+		fnval     = 0
+		forceHost = 0
+	)
+	convey.Convey("Ping", t, func(ctx convey.C) {
+		_, err := d.ArchivesWithPlayer(c, aids, qn, platform, fnver, fnval, forceHost, 0)
+		ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}

app/interface/main/app-feed/dao/archive/memcache.go

@@ -0,0 +1,102 @@
+package archive
+
+import (
+	"context"
+	"strconv"
+
+	"go-common/app/service/main/archive/api"
+	"go-common/library/cache/memcache"
+	"go-common/library/log"
+
+	"github.com/pkg/errors"
+)
+
+const (
+	_prefix   = "a3p_"
+	_prxfixSt = "stp_"
+)
+
+func keyArc(aid int64) string {
+	return _prefix + strconv.FormatInt(aid, 10)
+}
+
+func keySt(aid int64) string {
+	return _prxfixSt + strconv.FormatInt(aid, 10)
+}
+
+// statsCache get stat cache by aids
+func (d *Dao) statsCache(c context.Context, aids []int64) (cached map[int64]*api.Stat, missed []int64, err error) {
+	cached = make(map[int64]*api.Stat, len(aids))
+	var (
+		conn = d.mc.Get(c)
+		keys = make([]string, 0, len(aids))
+		rs   map[string]*memcache.Item
+	)
+	defer conn.Close()
+	for _, aid := range aids {
+		keys = append(keys, keySt(aid))
+	}
+	if rs, err = conn.GetMulti(keys); err != nil {
+		err = errors.Wrapf(err, "%v", keys)
+		return
+	}
+	for _, item := range rs {
+		var st = &api.Stat{}
+		if err = conn.Scan(item, st); err != nil {
+			log.Error("conn.Scan(%s) error(%v)", item.Value, err)
+			err = nil
+			continue
+		}
+		cached[st.Aid] = st
+	}
+	if len(cached) == len(aids) {
+		return
+	}
+	for _, aid := range aids {
+		if _, ok := cached[aid]; !ok {
+			missed = append(missed, aid)
+		}
+	}
+	return
+}
+
+// arcsCache get archives cache.
+func (d *Dao) arcsCache(c context.Context, aids []int64) (cached map[int64]*api.Arc, missed []int64, err error) {
+	var (
+		keys   = make([]string, 0, len(aids))
+		conn   = d.mc.Get(c)
+		aidmap = make(map[string]int64, len(aids))
+		rs     map[string]*memcache.Item
+		a      *api.Arc
+	)
+	cached = make(map[int64]*api.Arc, len(aids))
+	defer conn.Close()
+	for _, aid := range aids {
+		k := keyArc(aid)
+		if _, ok := aidmap[k]; !ok {
+			keys = append(keys, k)
+			aidmap[k] = aid
+		}
+	}
+	if rs, err = conn.GetMulti(keys); err != nil {
+		err = errors.Wrapf(err, "%v", keys)
+		return
+	}
+	for k, r := range rs {
+		a = &api.Arc{}
+		if err = conn.Scan(r, a); err != nil {
+			log.Error("conn.Scan(%s) error(%v)", r.Value, err)
+			err = nil
+			continue
+		}
+		cached[aidmap[k]] = a
+		// delete hit key
+		delete(aidmap, k)
+	}
+	// missed key
+	missed = make([]int64, 0, len(aidmap))
+	for _, aid := range aidmap {
+		missed = append(missed, aid)
+	}
+	return
+}

app/interface/main/app-feed/dao/archive/memcache_test.go

@@ -0,0 +1,20 @@
+package archive
+
+import (
+	"context"
+	"testing"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+func Test_statsCache(t *testing.T) {
+	Convey("should get statsCache", t, func() {
+		d.statsCache(context.Background(), []int64{1, 2, 3, 4})
+	})
+}
+
+func Test_arcsCache(t *testing.T) {
+	Convey("should get arcsCache", t, func() {
+		d.arcsCache(context.Background(), []int64{1, 2, 3, 4})
+	})
+}