Create & Init Project...

app/interface/main/app-feed/dao/upper/BUILD

@@ -0,0 +1,59 @@
+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",
+        "redis_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",
+        "redis.go",
+    ],
+    importpath = "go-common/app/interface/main/app-feed/dao/upper",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/app-feed/conf:go_default_library",
+        "//app/interface/openplatform/article/model:go_default_library",
+        "//app/service/main/archive/api:go_default_library",
+        "//app/service/main/feed/model:go_default_library",
+        "//app/service/main/feed/rpc/client:go_default_library",
+        "//library/cache/redis:go_default_library",
+        "//library/ecode:go_default_library",
+        "//library/log:go_default_library",
+        "//library/net/metadata:go_default_library",
+        "//library/xstr: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/upper/dao.go

@@ -0,0 +1,128 @@
+package upper
+
+import (
+	"context"
+	"time"
+
+	"go-common/app/interface/main/app-feed/conf"
+	article "go-common/app/interface/openplatform/article/model"
+	feed "go-common/app/service/main/feed/model"
+	feedrpc "go-common/app/service/main/feed/rpc/client"
+	"go-common/library/cache/redis"
+	"go-common/library/ecode"
+	"go-common/library/net/metadata"
+
+	"github.com/pkg/errors"
+)
+
+// Dao is feed dao.
+type Dao struct {
+	// rpc
+	feedRPC *feedrpc.Service
+	// redis
+	redis     *redis.Pool
+	expireRds int32
+}
+
+// New new a archive dao.
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		// rpc
+		feedRPC: feedrpc.New(c.FeedRPC),
+		// redis init
+		redis:     redis.NewPool(c.Redis.Upper.Config),
+		expireRds: int32(time.Duration(c.Redis.Upper.ExpireUpper) / time.Second),
+	}
+	return
+}
+
+// Ping check redis connection
+func (d *Dao) Ping(c context.Context) (err error) {
+	conn := d.redis.Get(c)
+	_, err = conn.Do("SET", "PING", "PONG")
+	conn.Close()
+	return
+}
+
+func (d *Dao) Feed(c context.Context, mid int64, pn, ps int) (fs []*feed.Feed, err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	arg := &feed.ArgFeed{Mid: mid, Pn: pn, Ps: ps, RealIP: ip}
+	if fs, err = d.feedRPC.AppFeed(c, arg); err != nil {
+		if err == ecode.NothingFound {
+			err = nil
+			return
+		}
+		err = errors.Wrapf(err, "%v", arg)
+	}
+	return
+}
+
+func (d *Dao) ArchiveFeed(c context.Context, mid int64, pn, ps int) (fs []*feed.Feed, err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	arg := &feed.ArgFeed{Mid: mid, Pn: pn, Ps: ps, RealIP: ip}
+	if fs, err = d.feedRPC.ArchiveFeed(c, arg); err != nil {
+		if err == ecode.NothingFound {
+			err = nil
+			return
+		}
+		err = errors.Wrapf(err, "%v", arg)
+	}
+	return
+}
+
+func (d *Dao) BangumiFeed(c context.Context, mid int64, pn, ps int) (fs []*feed.Feed, err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	arg := &feed.ArgFeed{Mid: mid, Pn: pn, Ps: ps, RealIP: ip}
+	if fs, err = d.feedRPC.BangumiFeed(c, arg); err != nil {
+		if err == ecode.NothingFound {
+			err = nil
+			return
+		}
+		err = errors.Wrapf(err, "%v", arg)
+	}
+	return
+}
+
+func (d *Dao) Recent(c context.Context, mid, aid int64) (fs []*feed.Feed, err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	arg := &feed.ArgFold{Mid: mid, Aid: aid, RealIP: ip}
+	if fs, err = d.feedRPC.Fold(c, arg); err != nil {
+		if err == ecode.NothingFound {
+			err = nil
+			return
+		}
+		err = errors.Wrapf(err, "%v", arg)
+	}
+	return
+}
+
+func (d *Dao) AppUnreadCount(c context.Context, mid int64, withoutBangumi bool) (unread int, err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	arg := &feed.ArgUnreadCount{Mid: mid, WithoutBangumi: withoutBangumi, RealIP: ip}
+	if unread, err = d.feedRPC.AppUnreadCount(c, arg); err != nil {
+		err = errors.Wrapf(err, "%v", arg)
+	}
+	return
+}
+
+func (d *Dao) ArticleFeed(c context.Context, mid int64, pn, ps int) (fs []*article.Meta, err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	arg := &feed.ArgFeed{Mid: mid, Pn: pn, Ps: ps, RealIP: ip}
+	if fs, err = d.feedRPC.ArticleFeed(c, arg); err != nil {
+		if err == ecode.NothingFound {
+			err = nil
+			return
+		}
+		err = errors.Wrapf(err, "%v", arg)
+	}
+	return
+}
+
+func (d *Dao) ArticleUnreadCount(c context.Context, mid int64) (unread int, err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	arg := &feed.ArgMid{Mid: mid, RealIP: ip}
+	if unread, err = d.feedRPC.ArticleUnreadCount(c, arg); err != nil {
+		err = errors.Wrapf(err, "%v", arg)
+	}
+	return
+}

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

@@ -0,0 +1,79 @@
+package upper
+
+import (
+	"context"
+	"flag"
+	"os"
+	"testing"
+
+	"go-common/app/interface/main/app-feed/conf"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+var (
+	d *Dao
+)
+
+func init() {
+	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")
+	} else {
+		flag.Set("conf", "../../cmd/app-feed-test.toml")
+	}
+	flag.Parse()
+	if err := conf.Init(); err != nil {
+		panic(err)
+	}
+	d = New(conf.Conf)
+}
+
+func Test_Feed(t *testing.T) {
+	Convey("should get Feed", t, func() {
+		_, err := d.Feed(context.Background(), 1, 2, 3)
+		So(err, ShouldBeNil)
+	})
+}
+
+func Test_ArchiveFeed(t *testing.T) {
+	Convey("should get ArchiveFeed", t, func() {
+		_, err := d.ArchiveFeed(context.Background(), 1, 2, 3)
+		So(err, ShouldBeNil)
+	})
+}
+
+func Test_BangumiFeed(t *testing.T) {
+	Convey("should get BangumiFeed", t, func() {
+		_, err := d.BangumiFeed(context.Background(), 1, 2, 3)
+		So(err, ShouldBeNil)
+	})
+}
+
+func Test_Recent(t *testing.T) {
+	Convey("should get Recent", t, func() {
+		_, err := d.Recent(context.Background(), 1, 2)
+		So(err, ShouldBeNil)
+	})
+}
+
+func Test_ArticleFeed(t *testing.T) {
+	Convey("should get ArticleFeed", t, func() {
+		_, err := d.ArticleFeed(context.Background(), 1, 2, 3)
+		So(err, ShouldBeNil)
+	})
+}
+
+func Test_ArticleUnreadCount(t *testing.T) {
+	Convey("should get ArticleUnreadCount", t, func() {
+		_, err := d.ArticleUnreadCount(context.Background(), 1)
+		So(err, ShouldBeNil)
+	})
+}

app/interface/main/app-feed/dao/upper/redis.go

@@ -0,0 +1,174 @@
+package upper
+
+import (
+	"context"
+	"strconv"
+
+	"go-common/app/service/main/archive/api"
+	feed "go-common/app/service/main/feed/model"
+	"go-common/library/log"
+	"go-common/library/xstr"
+
+	"go-common/library/cache/redis"
+
+	"github.com/pkg/errors"
+)
+
+const (
+	// up items
+	_prefixUpItems = "u3_"
+	// unread count
+	_prefixUnreadCount = "uc2_"
+)
+
+func keyUpItem(mid int64) string {
+	return _prefixUpItems + strconv.FormatInt(mid, 10)
+}
+
+func keyUnreadCount(mid int64) string {
+	return _prefixUnreadCount + strconv.FormatInt(mid%100000, 10)
+}
+
+func (d *Dao) UpItemCaches(c context.Context, mid int64, start, end int) (uis []*feed.Feed, aids []int64, seasonIDs []int64, err error) {
+	var vs []interface{}
+	conn := d.redis.Get(c)
+	key := keyUpItem(mid)
+	defer conn.Close()
+	if vs, err = redis.Values(conn.Do("ZREVRANGE", key, start, end, "WITHSCORES")); err != nil {
+		err = errors.Wrapf(err, "conn.Do(ZREVRANGE,%s,%d,%d)", key, start, end)
+		return
+	}
+	uis = make([]*feed.Feed, 0, len(vs))
+	aids = make([]int64, 0, len(vs))
+	seasonIDs = make([]int64, 0, len(vs))
+Loop:
+	for len(vs) > 0 {
+		var (
+			i      int64
+			value  string
+			values []int64
+		)
+		if vs, err = redis.Scan(vs, &value, &i); err != nil {
+			err = errors.Wrapf(err, "%v", vs)
+			return
+		}
+		if values, err = xstr.SplitInts(value); err != nil {
+			log.Error("xstr.SplitInts(%v) error(%v)", value, err)
+			continue Loop
+		}
+		if len(values) >= 2 {
+			ua := &feed.Feed{}
+			urs := make([]*api.Arc, 0, len(values)-2)
+			for k, v := range values {
+				if k == 0 {
+					ua.Type = v
+				} else if k == 1 {
+					ua.ID = v
+					switch ua.Type {
+					case feed.ArchiveType:
+						aids = append(aids, v)
+					case feed.BangumiType:
+						seasonIDs = append(seasonIDs, v)
+					}
+				} else if k >= 2 {
+					switch ua.Type {
+					case feed.ArchiveType:
+						aids = append(aids, v)
+						urs = append(urs, &api.Arc{Aid: v})
+					}
+				}
+			}
+			ua.Fold = urs
+			uis = append(uis, ua)
+		}
+	}
+	return
+}
+
+func (d *Dao) AddUpItemCaches(c context.Context, mid int64, uis ...*feed.Feed) (err error) {
+	var (
+		ucKey = keyUnreadCount(mid)
+		upKey = keyUpItem(mid)
+		conn  = d.redis.Get(c)
+	)
+	defer conn.Close()
+	if err = conn.Send("HSET", ucKey, mid, 0); err != nil {
+		err = errors.Wrapf(err, "conn.Send(HSET,%s,%d,%d) error(%v)", ucKey, mid, 0)
+		return
+	}
+	if err = conn.Send("ZREMRANGEBYRANK", upKey, 0, -1); err != nil {
+		err = errors.Wrapf(err, "conn.Send(ZREMRANGEBYRANK,%s,%d,%d)", upKey, 0, -1)
+		return
+	}
+	for _, ui := range uis {
+		if ui.ID != 0 && (ui.Type == feed.ArchiveType || ui.Type == feed.BangumiType) {
+			var vs = []int64{ui.Type, ui.ID}
+			for _, r := range ui.Fold {
+				if r.Aid != 0 {
+					vs = append(vs, r.Aid)
+				}
+			}
+			var (
+				score = ui.PubDate.Time().Unix()
+				value = xstr.JoinInts(vs)
+			)
+			if err = conn.Send("ZADD", upKey, score, value); err != nil {
+				err = errors.Wrapf(err, "conn.Send(ZADD,%s,%d,%d)", upKey, score, value)
+				return
+			}
+		}
+	}
+	if err = conn.Send("EXPIRE", upKey, d.expireRds); err != nil {
+		err = errors.Wrapf(err, "conn.Send(EXPIRE,%s,%d)", upKey, d.expireRds)
+		return
+	}
+	if err = conn.Flush(); err != nil {
+		return
+	}
+	for i := 0; i < len(uis)+3; i++ {
+		if _, err = conn.Receive(); err != nil {
+			return
+		}
+	}
+	return
+}
+
+func (d *Dao) ExpireUpItem(c context.Context, mid int64) (ok bool, err error) {
+	var (
+		key  = keyUpItem(mid)
+		conn = d.redis.Get(c)
+	)
+	defer conn.Close()
+	if ok, err = redis.Bool(conn.Do("EXPIRE", key, d.expireRds)); err != nil {
+		err = errors.Wrapf(err, "conn.Do(EXPIRE,%s,%d)", key, d.expireRds)
+	}
+	return
+}
+
+func (d *Dao) UnreadCountCache(c context.Context, mid int64) (unread int, err error) {
+	var (
+		key  = keyUnreadCount(mid)
+		conn = d.redis.Get(c)
+	)
+	defer conn.Close()
+	if unread, err = redis.Int(conn.Do("HGET", key, mid)); err != nil {
+		if err == redis.ErrNil {
+			err = nil
+			return
+		}
+		err = errors.Wrapf(err, "conn.Do(HGET,%s,%d)", key, mid)
+	}
+	return
+}
+
+func (d *Dao) AddUnreadCountCache(c context.Context, mid int64, unread int) (err error) {
+	var (
+		key  = keyUnreadCount(mid)
+		conn = d.redis.Get(c)
+	)
+	defer conn.Close()
+	if _, err = conn.Do("HSET", key, mid, unread); err != nil {
+		err = errors.Wrapf(err, "conn.DO(HSET,%s,%d,%d)", key, mid, unread)
+	}
+	return
+}

app/interface/main/app-feed/dao/upper/redis_test.go

@@ -0,0 +1,15 @@
+package upper
+
+import (
+	"context"
+	"testing"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+func Test_UnreadCountCache(t *testing.T) {
+	Convey("should get UnreadCountCache", t, func() {
+		_, err := d.UnreadCountCache(context.Background(), 1)
+		So(err, ShouldBeNil)
+	})
+}