Create & Init Project...

app/interface/main/app-intl/dao/recommend/BUILD

@@ -0,0 +1,61 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_test",
+    "go_library",
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = [
+        "api_test.go",
+        "dao_test.go",
+        "memcache_test.go",
+        "redis_test.go",
+    ],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/app-intl/conf:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "api.go",
+        "dao.go",
+        "memcache.go",
+        "redis.go",
+    ],
+    importpath = "go-common/app/interface/main/app-intl/dao/recommend",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/app-card/model:go_default_library",
+        "//app/interface/main/app-card/model/card/ai:go_default_library",
+        "//app/interface/main/app-intl/conf:go_default_library",
+        "//library/cache/memcache:go_default_library",
+        "//library/cache/redis:go_default_library",
+        "//library/ecode:go_default_library",
+        "//library/net/http/blademaster:go_default_library",
+        "//library/net/metadata: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-intl/dao/recommend/api.go

@@ -0,0 +1,124 @@
+package recommend
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/url"
+	"strconv"
+	"time"
+
+	"go-common/app/interface/main/app-card/model"
+	"go-common/app/interface/main/app-card/model/card/ai"
+	"go-common/library/ecode"
+	"go-common/library/net/metadata"
+
+	"github.com/pkg/errors"
+)
+
+const (
+	_rcmd  = "/pegasus/feed/%d"
+	_hot   = "/data/rank/reco-tmzb.json"
+	_group = "/group_changes/pegasus.json"
+	_top   = "/feed/tag/top"
+)
+
+// Recommend is.
+func (d *Dao) Recommend(c context.Context, plat int8, buvid string, mid int64, build, loginEvent int, zoneID int64, group int, interest, network string, style int, column model.ColumnStatus, flush int, autoplay string, now time.Time) (rs []*ai.Item, userFeature json.RawMessage, respCode int, newUser bool, err error) {
+	if mid == 0 && buvid == "" {
+		return
+	}
+	ip := metadata.String(c, metadata.RemoteIP)
+	uri := fmt.Sprintf(d.rcmd, group)
+	params := url.Values{}
+	params.Set("mid", strconv.FormatInt(mid, 10))
+	params.Set("buvid", buvid)
+	params.Set("plat", strconv.Itoa(int(plat)))
+	params.Set("build", strconv.Itoa(build))
+	params.Set("login_event", strconv.Itoa(loginEvent))
+	params.Set("zone_id", strconv.FormatInt(zoneID, 10))
+	params.Set("interest", interest)
+	params.Set("network", network)
+	if column > -1 {
+		params.Set("column", strconv.Itoa(int(column)))
+	}
+	params.Set("style", strconv.Itoa(style))
+	params.Set("flush", strconv.Itoa(flush))
+	params.Set("autoplay_card", autoplay)
+	var res struct {
+		Code        int             `json:"code"`
+		NewUser     bool            `json:"new_user"`
+		UserFeature json.RawMessage `json:"user_feature"`
+		Data        []*ai.Item      `json:"data"`
+	}
+	if err = d.client.Get(c, uri, ip, params, &res); err != nil {
+		respCode = ecode.ServerErr.Code()
+		return
+	}
+	code := ecode.Int(res.Code)
+	if !code.Equal(ecode.OK) {
+		respCode = res.Code
+		err = errors.Wrapf(code, "%s", uri+"?"+params.Encode())
+		return
+	}
+	rs = res.Data
+	userFeature = res.UserFeature
+	newUser = res.NewUser
+	return
+}
+
+// Hots is.
+func (d *Dao) Hots(c context.Context) (aids []int64, err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	var res struct {
+		Code int `json:"code"`
+		List []struct {
+			Aid int64 `json:"aid"`
+		} `json:"list"`
+	}
+	if err = d.clientAsyn.Get(c, d.hot, ip, nil, &res); err != nil {
+		return
+	}
+	code := ecode.Int(res.Code)
+	if !code.Equal(ecode.OK) {
+		err = errors.Wrapf(code, "%s", d.hot)
+		return
+	}
+	for _, list := range res.List {
+		if list.Aid != 0 {
+			aids = append(aids, list.Aid)
+		}
+	}
+	return
+}
+
+// TagTop is.
+func (d *Dao) TagTop(c context.Context, mid, tid int64, rn int) (aids []int64, err error) {
+	params := url.Values{}
+	params.Set("src", "2")
+	params.Set("pn", "1")
+	params.Set("mid", strconv.FormatInt(mid, 10))
+	params.Set("tag", strconv.FormatInt(tid, 10))
+	params.Set("rn", strconv.Itoa(rn))
+	var res struct {
+		Code int     `json:"code"`
+		Data []int64 `json:"data"`
+	}
+	if err = d.client.Get(c, d.top, "", params, &res); err != nil {
+		return
+	}
+	code := ecode.Int(res.Code)
+	if !code.Equal(ecode.OK) {
+		err = errors.Wrapf(code, "%s", d.top+"?"+params.Encode())
+		return
+	}
+	aids = res.Data
+	return
+}
+
+// Group is.
+func (d *Dao) Group(c context.Context) (gm map[int64]int, err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	err = d.clientAsyn.Get(c, d.group, ip, nil, &gm)
+	return
+}

app/interface/main/app-intl/dao/recommend/api_test.go

@@ -0,0 +1,65 @@
+package recommend
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+func TestRecommend(t *testing.T) {
+	Convey(t.Name(), t, func() {
+		_, _, _, _, err := d.Recommend(context.Background(), 1, "", 12, 123232, 2, 0, 2, "", "", 0, 1, 1, "", time.Now())
+		if err != nil {
+			t.Log(err)
+		}
+		if err != nil {
+			t.Log(err)
+		}
+		err = nil
+		So(err, ShouldBeNil)
+	})
+}
+
+func TestHots(t *testing.T) {
+	Convey(t.Name(), t, func() {
+		_, err := d.Hots(context.Background())
+		if err != nil {
+			t.Log(err)
+		}
+		if err != nil {
+			t.Log(err)
+		}
+		err = nil
+		So(err, ShouldBeNil)
+	})
+}
+
+func TestTagTop(t *testing.T) {
+	Convey(t.Name(), t, func() {
+		_, err := d.TagTop(context.Background(), 12, 12, 12)
+		if err != nil {
+			t.Log(err)
+		}
+		if err != nil {
+			t.Log(err)
+		}
+		err = nil
+		So(err, ShouldBeNil)
+	})
+}
+
+func TestGroup(t *testing.T) {
+	Convey(t.Name(), t, func() {
+		_, err := d.Group(context.Background())
+		if err != nil {
+			t.Log(err)
+		}
+		if err != nil {
+			t.Log(err)
+		}
+		err = nil
+		So(err, ShouldBeNil)
+	})
+}

app/interface/main/app-intl/dao/recommend/dao.go

@@ -0,0 +1,61 @@
+package recommend
+
+import (
+	"time"
+
+	"go-common/app/interface/main/app-intl/conf"
+	"go-common/library/cache/memcache"
+	"go-common/library/cache/redis"
+	httpx "go-common/library/net/http/blademaster"
+)
+
+// Dao is show dao.
+type Dao struct {
+	// http client
+	client     *httpx.Client
+	clientAsyn *httpx.Client
+	// hetongzi
+	hot string
+	// bigdata
+	rcmd  string
+	group string
+	top   string
+	// redis
+	redis     *redis.Pool
+	expireRds int
+	// mc
+	mc       *memcache.Pool
+	expireMc int32
+}
+
+// New new a show dao.
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		// http client
+		client:     httpx.NewClient(c.HTTPData),
+		clientAsyn: httpx.NewClient(c.HTTPClientAsyn),
+		// hetongzi
+		hot: c.Host.Hetongzi + _hot,
+		// bigdata
+		rcmd:  c.Host.Data + _rcmd,
+		group: c.Host.BigData + _group,
+		top:   c.Host.Data + _top,
+		// redis
+		redis:     redis.NewPool(c.Redis.Feed.Config),
+		expireRds: int(time.Duration(c.Redis.Feed.ExpireRecommend) / time.Second),
+		// mc
+		mc:       memcache.NewPool(c.Memcache.Cache.Config),
+		expireMc: int32(time.Duration(c.Memcache.Cache.Expire) / time.Second),
+	}
+	return
+}
+
+// Close close resource.
+func (d *Dao) Close() {
+	if d.redis != nil {
+		d.redis.Close()
+	}
+	if d.mc != nil {
+		d.mc.Close()
+	}
+}

app/interface/main/app-intl/dao/recommend/dao_test.go

@@ -0,0 +1,41 @@
+package recommend
+
+import (
+	"flag"
+	"go-common/app/interface/main/app-intl/conf"
+	"os"
+	"testing"
+
+	. "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-intl")
+		flag.Set("conf_token", "02007e8d0f77d31baee89acb5ce6d3ac")
+		flag.Set("tree_id", "64518")
+		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-intl-test.toml")
+	}
+	flag.Parse()
+	if err := conf.Init(); err != nil {
+		panic(err)
+	}
+	d = New(conf.Conf)
+	os.Exit(m.Run())
+}
+func TestClose(t *testing.T) {
+	Convey(t.Name(), t, func() {
+		d.Close()
+	})
+}

app/interface/main/app-intl/dao/recommend/memcache.go

@@ -0,0 +1,87 @@
+package recommend
+
+import (
+	"context"
+
+	"go-common/app/interface/main/app-card/model/card/ai"
+	"go-common/library/cache/memcache"
+
+	"github.com/pkg/errors"
+)
+
+const (
+	_prefixRcmdAids = "rc"
+	_prefixRcmd     = "rc2"
+)
+
+func keyRcmdAids() string {
+	return _prefixRcmdAids
+}
+
+func keyRcmd() string {
+	return _prefixRcmd
+}
+
+// AddRcmdAidsCache add ai into cahce.
+func (d *Dao) AddRcmdAidsCache(c context.Context, aids []int64) (err error) {
+	conn := d.mc.Get(c)
+	key := keyRcmdAids()
+	item := &memcache.Item{Key: key, Object: aids, Flags: memcache.FlagJSON, Expiration: d.expireMc}
+	if err = conn.Set(item); err != nil {
+		err = errors.Wrapf(err, "%v", aids)
+	}
+	conn.Close()
+	return
+}
+
+// RcmdAidsCache get ai cache data from cache
+func (d *Dao) RcmdAidsCache(c context.Context) (aids []int64, err error) {
+	var r *memcache.Item
+	conn := d.mc.Get(c)
+	key := keyRcmdAids()
+	defer conn.Close()
+	if r, err = conn.Get(key); err != nil {
+		if err == memcache.ErrNotFound {
+			err = nil
+			return
+		}
+		err = errors.Wrap(err, key)
+		return
+	}
+	if err = conn.Scan(r, &aids); err != nil {
+		err = errors.Wrapf(err, "%s", r.Value)
+	}
+	return
+}
+
+// AddRcmdCache add ai into cahce.
+func (d *Dao) AddRcmdCache(c context.Context, is []*ai.Item) (err error) {
+	conn := d.mc.Get(c)
+	key := keyRcmd()
+	item := &memcache.Item{Key: key, Object: is, Flags: memcache.FlagJSON, Expiration: d.expireMc}
+	if err = conn.Set(item); err != nil {
+		err = errors.Wrap(err, key)
+	}
+	conn.Close()
+	return
+}
+
+// RcmdCache get ai cache data from cache
+func (d *Dao) RcmdCache(c context.Context) (is []*ai.Item, err error) {
+	var r *memcache.Item
+	conn := d.mc.Get(c)
+	key := keyRcmd()
+	defer conn.Close()
+	if r, err = conn.Get(key); err != nil {
+		if err == memcache.ErrNotFound {
+			err = nil
+			return
+		}
+		err = errors.Wrap(err, key)
+		return
+	}
+	if err = conn.Scan(r, &is); err != nil {
+		err = errors.Wrapf(err, "%s", r.Value)
+	}
+	return
+}

app/interface/main/app-intl/dao/recommend/memcache_test.go

@@ -0,0 +1,41 @@
+package recommend
+
+import (
+	"context"
+	"testing"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+func TestAddRcmdAidsCache(t *testing.T) {
+	Convey(t.Name(), t, func() {
+		err := d.AddRcmdAidsCache(context.Background(), []int64{12})
+		if err != nil {
+			t.Log(err)
+		}
+		err = nil
+		So(err, ShouldBeNil)
+	})
+}
+
+func TestRcmdAidsCache(t *testing.T) {
+	Convey(t.Name(), t, func() {
+		_, err := d.RcmdAidsCache(context.Background())
+		if err != nil {
+			t.Log(err)
+		}
+		err = nil
+		So(err, ShouldBeNil)
+	})
+}
+
+func TestRcmdCache(t *testing.T) {
+	Convey(t.Name(), t, func() {
+		_, err := d.RcmdCache(context.Background())
+		if err != nil {
+			t.Log(err)
+		}
+		err = nil
+		So(err, ShouldBeNil)
+	})
+}

app/interface/main/app-intl/dao/recommend/redis.go

@@ -0,0 +1,50 @@
+package recommend
+
+import (
+	"context"
+	"strconv"
+
+	"go-common/library/cache/redis"
+
+	"github.com/pkg/errors"
+)
+
+const (
+	// _prefixPos is.
+	_prefixPos = "p_"
+)
+
+// keyPos is.
+func keyPos(mid int64) string {
+	return _prefixPos + strconv.FormatInt(mid%100000, 10)
+}
+
+// PositionCache is.
+func (d *Dao) PositionCache(c context.Context, mid int64) (pos int, err error) {
+	var (
+		key  = keyPos(mid)
+		conn = d.redis.Get(c)
+	)
+	defer conn.Close()
+	if pos, 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
+}
+
+// AddPositionCache is.
+func (d *Dao) AddPositionCache(c context.Context, mid int64, pos int) (err error) {
+	var (
+		key  = keyPos(mid)
+		conn = d.redis.Get(c)
+	)
+	defer conn.Close()
+	if _, err = conn.Do("HSET", key, mid, pos); err != nil {
+		err = errors.Wrapf(err, "conn.Do(HSET,%s,%d,%d)", key, mid, pos)
+	}
+	return
+}

app/interface/main/app-intl/dao/recommend/redis_test.go

@@ -0,0 +1,30 @@
+package recommend
+
+import (
+	"context"
+	"testing"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+func TestPositionCache(t *testing.T) {
+	Convey(t.Name(), t, func() {
+		_, err := d.PositionCache(context.Background(), 12)
+		if err != nil {
+			t.Log(err)
+		}
+		err = nil
+		So(err, ShouldBeNil)
+	})
+}
+
+func TestAddPositionCache(t *testing.T) {
+	Convey(t.Name(), t, func() {
+		err := d.AddPositionCache(context.Background(), 12, 1)
+		if err != nil {
+			t.Log(err)
+		}
+		err = nil
+		So(err, ShouldBeNil)
+	})
+}