Create & Init Project...

app/service/main/up/dao/archive/BUILD

@@ -0,0 +1,64 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_test",
+    "go_library",
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = [
+        "archive_test.go",
+        "dao_test.go",
+        "upper_rds_test.go",
+        "upper_staff_test.go",
+        "upper_test.go",
+    ],
+    embed = [":go_default_library"],
+    tags = ["automanaged"],
+    deps = [
+        "//app/service/main/up/conf:go_default_library",
+        "//library/time:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "archive.go",
+        "dao.go",
+        "upper.go",
+        "upper_rds.go",
+        "upper_staff.go",
+    ],
+    importpath = "go-common/app/service/main/up/dao/archive",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/service/main/up/conf:go_default_library",
+        "//app/service/main/up/model:go_default_library",
+        "//library/cache/redis:go_default_library",
+        "//library/database/sql:go_default_library",
+        "//library/log:go_default_library",
+        "//library/stat/prom:go_default_library",
+        "//library/time: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/service/main/up/dao/archive/archive.go

@@ -0,0 +1,45 @@
+package archive
+
+import (
+	"context"
+	"fmt"
+
+	"go-common/app/service/main/up/model"
+	"go-common/library/database/sql"
+	"go-common/library/time"
+	"go-common/library/xstr"
+)
+
+const (
+	_arcsAidsSQL = "SELECT aid,pubtime,copyright FROM archive WHERE aid IN (%s) AND state>=0 ORDER BY pubtime DESC"
+)
+
+// ArcsAids get archives by aids.
+func (d *Dao) ArcsAids(c context.Context, ids []int64) (aids []int64, ptimes []time.Time, copyrights []int8, aptm map[int64]*model.AidPubTime, err error) {
+	d.infoProm.Incr("ArcAids")
+	rows, err := d.resultDB.Query(c, fmt.Sprintf(_arcsAidsSQL, xstr.JoinInts(ids)))
+	if err != nil {
+		return
+	}
+	defer rows.Close()
+	aptm = make(map[int64]*model.AidPubTime, len(ids))
+	for rows.Next() {
+		var (
+			aid       int64
+			ptime     time.Time
+			copyright int8
+		)
+		if err = rows.Scan(&aid, &ptime, &copyright); err != nil {
+			if err == sql.ErrNoRows {
+				err = nil
+				return
+			}
+			return
+		}
+		aptm[aid] = &model.AidPubTime{Aid: aid, PubDate: ptime, Copyright: copyright}
+		aids = append(aids, aid)
+		ptimes = append(ptimes, ptime)
+		copyrights = append(copyrights, copyright)
+	}
+	return
+}

app/service/main/up/dao/archive/archive_test.go

@@ -0,0 +1,27 @@
+package archive
+
+import (
+	"context"
+	"testing"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestArchiveArcsAids(t *testing.T) {
+	convey.Convey("ArcsAids", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			ids = []int64{10110188}
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			aids, ptimes, copyrights, aptm, err := d.ArcsAids(c, ids)
+			ctx.Convey("Then err should be nil.aids,ptimes,copyrights,aptm should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(aptm, convey.ShouldNotBeNil)
+				ctx.So(copyrights, convey.ShouldNotBeNil)
+				ctx.So(ptimes, convey.ShouldNotBeNil)
+				ctx.So(aids, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}

app/service/main/up/dao/archive/dao.go

@@ -0,0 +1,38 @@
+package archive
+
+import (
+	"time"
+
+	"go-common/app/service/main/up/conf"
+	"go-common/library/cache/redis"
+	"go-common/library/database/sql"
+	"go-common/library/stat/prom"
+)
+
+// Dao is archive dao.
+type Dao struct {
+	c         *conf.Config
+	resultDB  *sql.DB
+	archiveDB *sql.DB
+	// redis
+	upRds    *redis.Pool
+	upExpire int32
+	errProm  *prom.Prom
+	infoProm *prom.Prom
+}
+
+// New new a Dao and return.
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		c: c,
+		// db
+		resultDB:  sql.NewMySQL(c.DB.ArcResult),
+		archiveDB: sql.NewMySQL(c.DB.Archive),
+		// redis
+		upRds:    redis.NewPool(c.Redis.Up.Config),
+		upExpire: int32(time.Duration(c.Redis.Up.UpExpire) / time.Second),
+		errProm:  prom.BusinessErrCount,
+		infoProm: prom.BusinessInfoCount,
+	}
+	return
+}

app/service/main/up/dao/archive/dao_test.go

@@ -0,0 +1,39 @@
+package archive
+
+import (
+	"flag"
+	"os"
+	"testing"
+
+	"go-common/app/service/main/up/conf"
+)
+
+var (
+	d *Dao
+)
+
+func TestMain(m *testing.M) {
+	if os.Getenv("DEPLOY_ENV") != "" {
+		flag.Set("app_id", "main.archive.up-service")
+		flag.Set("conf_token", "5f1660060bb011e8865c66d44b23cda7")
+		flag.Set("tree_id", "15572")
+		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/up-service.toml")
+	}
+	if os.Getenv("UT_LOCAL_TEST") != "" {
+		flag.Set("conf", "../../cmd/up-service.toml")
+	}
+	flag.Parse()
+	if err := conf.Init(); err != nil {
+		panic(err)
+	}
+	d = New(conf.Conf)
+	m.Run()
+	os.Exit(0)
+}

app/service/main/up/dao/archive/upper.go

@@ -0,0 +1,107 @@
+package archive
+
+import (
+	"context"
+	"fmt"
+
+	"go-common/library/log"
+	"go-common/library/time"
+	"go-common/library/xstr"
+
+	"github.com/pkg/errors"
+)
+
+const (
+	_upCntSQL  = "SELECT COUNT(*) FROM archive WHERE mid=? AND (state>=0 or state=-6)"
+	_upsCntSQL = "SELECT mid,COUNT(*) FROM archive WHERE mid IN(%s) AND (state>=0 or state=-6) GROUP BY mid"
+	_upPasSQL  = "SELECT aid,pubtime,copyright FROM archive WHERE mid=? AND state>=0 ORDER BY pubtime DESC"
+	_upsPasSQL = "SELECT aid,mid,pubtime,copyright FROM archive WHERE mid IN (%s) AND state>=0 ORDER BY pubtime DESC"
+)
+
+// UppersCount get mids count
+func (d *Dao) UppersCount(c context.Context, mids []int64) (uc map[int64]int64, err error) {
+	rows, err := d.resultDB.Query(c, fmt.Sprintf(_upsCntSQL, xstr.JoinInts(mids)))
+	if err != nil {
+		err = errors.WithStack(err)
+		return
+	}
+	uc = make(map[int64]int64, len(mids))
+	defer rows.Close()
+	for rows.Next() {
+		var (
+			mid int64
+			cnt int64
+		)
+		if err = rows.Scan(&mid, &cnt); err != nil {
+			err = errors.WithStack(err)
+			return
+		}
+		uc[mid] = cnt
+	}
+	return
+}
+
+// UpperCount get the count of archives by mid of Up.
+func (d *Dao) UpperCount(c context.Context, mid int64) (count int64, err error) {
+	d.infoProm.Incr("UpperCount")
+	row := d.resultDB.QueryRow(c, _upCntSQL, mid)
+	if err = row.Scan(&count); err != nil {
+		log.Error("row.Scan error(%v)", err)
+	}
+	return
+}
+
+// UpperPassed get upper passed archives.
+func (d *Dao) UpperPassed(c context.Context, mid int64) (aids []int64, ptimes []time.Time, copyrights []int8, err error) {
+	d.infoProm.Incr("UpperPassed")
+	rows, err := d.resultDB.Query(c, _upPasSQL, mid)
+	if err != nil {
+		log.Error("getUpPasStmt.Query(%d) error(%v)", mid, err)
+		return
+	}
+	defer rows.Close()
+	for rows.Next() {
+		var (
+			aid       int64
+			ptime     time.Time
+			copyright int8
+		)
+		if err = rows.Scan(&aid, &ptime, &copyright); err != nil {
+			log.Error("rows.Scan error(%v)", err)
+			return
+		}
+		aids = append(aids, aid)
+		ptimes = append(ptimes, ptime)
+		copyrights = append(copyrights, copyright)
+	}
+	return
+}
+
+// UppersPassed get uppers passed archives.
+func (d *Dao) UppersPassed(c context.Context, mids []int64) (aidm map[int64][]int64, ptimes map[int64][]time.Time, copyrights map[int64][]int8, err error) {
+	d.infoProm.Incr("UppersPassed")
+	rows, err := d.resultDB.Query(c, fmt.Sprintf(_upsPasSQL, xstr.JoinInts(mids)))
+	if err != nil {
+		log.Error("UpsPassed error(%v)", err)
+		return
+	}
+	defer rows.Close()
+	aidm = make(map[int64][]int64, len(mids))
+	ptimes = make(map[int64][]time.Time, len(mids))
+	copyrights = make(map[int64][]int8, len(mids))
+	for rows.Next() {
+		var (
+			aid, mid  int64
+			ptime     time.Time
+			copyright int8
+		)
+		if err = rows.Scan(&aid, &mid, &ptime, &copyright); err != nil {
+			log.Error("rows.Scan error(%v)", err)
+			return
+		}
+		aidm[mid] = append(aidm[mid], aid)
+		ptimes[mid] = append(ptimes[mid], ptime)
+		copyrights[mid] = append(copyrights[mid], copyright)
+	}
+	return
+}

app/service/main/up/dao/archive/upper_rds.go

@@ -0,0 +1,316 @@
+package archive
+
+import (
+	"context"
+	"strconv"
+
+	"go-common/app/service/main/up/model"
+	"go-common/library/cache/redis"
+	"go-common/library/log"
+	"go-common/library/time"
+)
+
+const (
+	_prefixUpCnt = "uc_"
+	_prefixUpPas = "up_"
+)
+
+func upCntKey(mid int64) string {
+	return _prefixUpCnt + strconv.FormatInt(mid, 10)
+}
+
+func upPasKey(mid int64) string {
+	return _prefixUpPas + strconv.FormatInt(mid, 10)
+}
+
+// AddUpperCountCache the count of up's archives
+func (d *Dao) AddUpperCountCache(c context.Context, mid int64, count int64) (err error) {
+	var (
+		key        = upCntKey(mid)
+		conn       = d.upRds.Get(c)
+		expireTime = d.upExpire
+	)
+	defer conn.Close()
+	if count == 0 {
+		expireTime = 600
+	}
+	if _, err = conn.Do("SETEX", key, expireTime, count); err != nil {
+		log.Error("conn.Do(SETEX, %s, %d, %d)", key, expireTime, count)
+		return
+	}
+	return
+}
+
+// UpperCountCache get up count from cache.
+func (d *Dao) UpperCountCache(c context.Context, mid int64) (count int64, err error) {
+	var (
+		key  = upCntKey(mid)
+		conn = d.upRds.Get(c)
+	)
+	defer conn.Close()
+	if count, err = redis.Int64(conn.Do("GET", key)); err != nil {
+		if err == redis.ErrNil {
+			count = -1
+			err = nil
+		} else {
+			d.errProm.Incr("upper_redis")
+			log.Error("conn.Do(GET, %s) error(%v)", key, err)
+		}
+	}
+	return
+}
+
+// UppersCountCache return uppers count cache
+func (d *Dao) UppersCountCache(c context.Context, mids []int64) (cached map[int64]int64, missed []int64, err error) {
+	conn := d.upRds.Get(c)
+	defer conn.Close()
+	cached = make(map[int64]int64)
+	for _, mid := range mids {
+		key := upCntKey(mid)
+		if err = conn.Send("GET", key); err != nil {
+			missed = mids
+			continue
+		}
+	}
+	if err = conn.Flush(); err != nil {
+		missed = mids
+		return
+	}
+	for _, mid := range mids {
+		var cnt int64
+		if cnt, err = redis.Int64(conn.Receive()); err != nil {
+			if err == redis.ErrNil {
+				missed = append(missed, mid)
+				err = nil
+				continue
+			}
+		}
+		cached[mid] = int64(cnt)
+	}
+	return
+}
+
+// UpperPassedCache get upper passed archives from cache.
+func (d *Dao) UpperPassedCache(c context.Context, mid int64, start, end int) (aids []int64, err error) {
+	var (
+		key  = upPasKey(mid)
+		conn = d.upRds.Get(c)
+	)
+	defer conn.Close()
+	if aids, err = redis.Int64s(conn.Do("ZREVRANGE", key, start, end)); err != nil {
+		d.errProm.Incr("upper_redis")
+		log.Error("conn.Do(ZRANGE, %s, 0, -1) error(%v)", key, err)
+	}
+	return
+}
+
+// UppersPassedCacheWithScore get uppers passed archive from cache with score
+func (d *Dao) UppersPassedCacheWithScore(c context.Context, mids []int64, start, end int) (aidm map[int64][]*model.AidPubTime, err error) {
+	conn := d.upRds.Get(c)
+	defer conn.Close()
+	aidm = make(map[int64][]*model.AidPubTime, len(mids))
+	for _, mid := range mids {
+		key := upPasKey(mid)
+		if err = conn.Send("ZREVRANGE", key, start, end, "WITHSCORES"); err != nil {
+			d.errProm.Incr("upper_redis")
+			log.Error("conn.Send(ZREVRANGE, %s) error(%v)", key, err)
+			return
+		}
+	}
+	if err = conn.Flush(); err != nil {
+		log.Error("conn.Flush error(%v)", err)
+		return
+	}
+	for _, mid := range mids {
+		aidScores, err := redis.Int64s(conn.Receive())
+		if err != nil {
+			d.errProm.Incr("upper_redis")
+			log.Error("conn.Do(GET, %d) error(%v)", mid, err)
+			continue
+		}
+		for i := 0; i < len(aidScores); i += 2 {
+			var (
+				score     int64
+				ptime     int64
+				copyright int8
+			)
+			score = aidScores[i+1]
+			if score > 1000000000 {
+				ptime = score >> 2
+				copyright = int8(score & 3)
+				aidm[mid] = append(aidm[mid], &model.AidPubTime{Aid: aidScores[i], PubDate: time.Time(ptime), Copyright: copyright})
+			} else {
+				aidm[mid] = append(aidm[mid], &model.AidPubTime{Aid: aidScores[i], PubDate: time.Time(score)})
+			}
+		}
+	}
+	return
+}
+
+// UppersPassedCache get uppers passed archives from cache.
+func (d *Dao) UppersPassedCache(c context.Context, mids []int64, start, end int) (aidm map[int64][]int64, err error) {
+	conn := d.upRds.Get(c)
+	defer conn.Close()
+	aidm = make(map[int64][]int64, len(mids))
+	for _, mid := range mids {
+		key := upPasKey(mid)
+		if err = conn.Send("ZREVRANGE", key, start, end); err != nil {
+			d.errProm.Incr("upper_redis")
+			log.Error("conn.Send(ZREVRANGE, %s) error(%v)", key, err)
+			return
+		}
+	}
+	if err = conn.Flush(); err != nil {
+		log.Error("conn.Flush error(%v)", err)
+		return
+	}
+	for _, mid := range mids {
+		aids, err := redis.Int64s(conn.Receive())
+		if err != nil {
+			d.errProm.Incr("upper_redis")
+			log.Error("conn.Do(GET, %d) error(%v)", mid, err)
+			continue
+		}
+		aidm[mid] = aids
+	}
+	return
+}
+
+// ExpireUpperPassedCache expire up passed cache.
+func (d *Dao) ExpireUpperPassedCache(c context.Context, mid int64) (ok bool, err error) {
+	var (
+		key  = upPasKey(mid)
+		conn = d.upRds.Get(c)
+	)
+	defer conn.Close()
+	if ok, err = redis.Bool(conn.Do("EXPIRE", key, d.upExpire)); err != nil {
+		d.errProm.Incr("upper_redis")
+		log.Error("conn.Do(EXPIRE, %s, %d) error(%v)", key, d.upExpire, err)
+	}
+	return
+}
+
+// ExpireUppersCountCache expire ups count cache
+func (d *Dao) ExpireUppersCountCache(c context.Context, mids []int64) (cachedUp, missed []int64, err error) {
+	var conn = d.upRds.Get(c)
+	defer conn.Close()
+	defer func() {
+		if err != nil {
+			d.errProm.Incr("upper_redis")
+		}
+	}()
+	for _, mid := range mids {
+		var key = upCntKey(mid)
+		if err = conn.Send("GET", key); err != nil {
+			log.Error("conn.Send(GET, %s) error(%v)", key, err)
+			return
+		}
+	}
+	for _, mid := range mids {
+		var key = upCntKey(mid)
+		if err = conn.Send("EXPIRE", key, d.upExpire); err != nil {
+			log.Error("conn.Send(GET, %s) error(%v)", key, err)
+			return
+		}
+	}
+	if err = conn.Flush(); err != nil {
+		log.Error("conn.Flush error(%v)", err)
+		return
+	}
+	cachedUp = make([]int64, 0)
+	missed = make([]int64, 0)
+	for _, mid := range mids {
+		var cnt int
+		if cnt, err = redis.Int(conn.Receive()); err != nil {
+			if err == redis.ErrNil {
+				err = nil
+				missed = append(missed, mid)
+			} else {
+				log.Error("conn.Receive error(%v)", err)
+				return
+			}
+		} else if cnt > 0 {
+			cachedUp = append(cachedUp, mid)
+		}
+	}
+	for _, mid := range mids {
+		if _, err = redis.Bool(conn.Receive()); err != nil {
+			log.Error("conn.Receive mid(%d) error(%v)", mid, err)
+			return
+		}
+	}
+	return
+}
+
+// ExpireUppersPassedCache expire uppers passed cache.
+func (d *Dao) ExpireUppersPassedCache(c context.Context, mids []int64) (res map[int64]bool, err error) {
+	conn := d.upRds.Get(c)
+	defer conn.Close()
+	res = make(map[int64]bool, len(mids))
+	for _, mid := range mids {
+		key := upPasKey(mid)
+		if err = conn.Send("EXPIRE", key, d.upExpire); err != nil {
+			d.errProm.Incr("upper_redis")
+			log.Error("conn.Send(%s) error(%v)", key, err)
+			return
+		}
+	}
+	if err = conn.Flush(); err != nil {
+		log.Error("conn.Flush error(%v)", err)
+		return
+	}
+	var ok bool
+	for _, mid := range mids {
+		if ok, err = redis.Bool(conn.Receive()); err != nil {
+			d.errProm.Incr("upper_redis")
+			log.Error("conn.Receive() error(%v)", err)
+			return
+		}
+		res[mid] = ok
+	}
+	return
+}
+
+// AddUpperPassedCache add up paassed cache.
+func (d *Dao) AddUpperPassedCache(c context.Context, mid int64, aids []int64, ptimes []time.Time, copyrights []int8) (err error) {
+	var (
+		key  = upPasKey(mid)
+		conn = d.upRds.Get(c)
+	)
+	defer conn.Close()
+	for k, aid := range aids {
+		score := int64(ptimes[k]<<2) | int64(copyrights[k])
+		if err = conn.Send("ZADD", key, score, aid); err != nil {
+			d.errProm.Incr("upper_redis")
+			log.Error("conn.Send(ZADD, %s, %d, %d) error(%v)", key, aid, ptimes[k], err)
+			return
+		}
+	}
+	if err = conn.Flush(); err != nil {
+		d.errProm.Incr("upper_redis")
+		log.Error("conn.Flush error(%v)", err)
+		return
+	}
+	for i := 0; i < len(aids); i++ {
+		if _, err = conn.Receive(); err != nil {
+			d.errProm.Incr("upper_redis")
+			log.Error("conn.Receive error(%v)", err)
+			return
+		}
+	}
+	return
+}
+
+// DelUpperPassedCache delete up passed cache.
+func (d *Dao) DelUpperPassedCache(c context.Context, mid, aid int64) (err error) {
+	var (
+		key  = upPasKey(mid)
+		conn = d.upRds.Get(c)
+	)
+	defer conn.Close()
+	if _, err = conn.Do("ZREM", key, aid); err != nil {
+		d.errProm.Incr("upper_redis")
+		log.Error("conn.Do(ZERM, %s, %d) error(%v)", key, aid, err)
+	}
+	return
+}

app/service/main/up/dao/archive/upper_rds_test.go

@@ -0,0 +1,197 @@
+package archive
+
+import (
+	"context"
+	"testing"
+
+	"go-common/library/time"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestArchiveupCntKey(t *testing.T) {
+	var (
+		mid = int64(1)
+	)
+	convey.Convey("upCntKey", t, func(ctx convey.C) {
+		p1 := upCntKey(mid)
+		ctx.Convey("Then p1 should not be nil.", func(ctx convey.C) {
+			ctx.So(p1, convey.ShouldNotBeNil)
+		})
+	})
+}
+
+func TestArchiveupPasKey(t *testing.T) {
+	var (
+		mid = int64(1)
+	)
+	convey.Convey("upPasKey", t, func(ctx convey.C) {
+		p1 := upPasKey(mid)
+		ctx.Convey("Then p1 should not be nil.", func(ctx convey.C) {
+			ctx.So(p1, convey.ShouldNotBeNil)
+		})
+	})
+}
+
+func TestArchiveAddUpperCountCache(t *testing.T) {
+	var (
+		c     = context.TODO()
+		mid   = int64(1)
+		count = int64(10)
+	)
+	convey.Convey("AddUpperCountCache", t, func(ctx convey.C) {
+		err := d.AddUpperCountCache(c, mid, count)
+		ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestArchiveUpperCountCache(t *testing.T) {
+	var (
+		c   = context.TODO()
+		mid = int64(1)
+	)
+	convey.Convey("UpperCountCache", t, func(ctx convey.C) {
+		count, err := d.UpperCountCache(c, mid)
+		ctx.Convey("Then err should be nil.count should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+			ctx.So(count, convey.ShouldNotBeNil)
+		})
+	})
+}
+
+func TestArchiveUppersCountCache(t *testing.T) {
+	var (
+		c    = context.TODO()
+		mids = []int64{1, 2}
+	)
+	convey.Convey("UppersCountCache", t, func(ctx convey.C) {
+		cached, missed, err := d.UppersCountCache(c, mids)
+		ctx.Convey("Then err should be nil.cached,missed should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+			ctx.So(missed, convey.ShouldNotBeNil)
+			ctx.So(cached, convey.ShouldNotBeNil)
+		})
+	})
+}
+
+func TestArchiveUpperPassedCache(t *testing.T) {
+	var (
+		c     = context.TODO()
+		mid   = int64(1)
+		start = int(0)
+		end   = int(10)
+	)
+	convey.Convey("UpperPassedCache", t, func(ctx convey.C) {
+		_, err := d.UpperPassedCache(c, mid, start, end)
+		ctx.Convey("Then err should be nil.aids should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestArchiveUppersPassedCacheWithScore(t *testing.T) {
+	var (
+		c     = context.TODO()
+		mids  = []int64{1, 2}
+		start = int(0)
+		end   = int(10)
+	)
+	convey.Convey("UppersPassedCacheWithScore", t, func(ctx convey.C) {
+		aidm, err := d.UppersPassedCacheWithScore(c, mids, start, end)
+		ctx.Convey("Then err should be nil.aidm should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+			ctx.So(aidm, convey.ShouldNotBeNil)
+		})
+	})
+}
+
+func TestArchiveUppersPassedCache(t *testing.T) {
+	var (
+		c     = context.TODO()
+		mids  = []int64{1, 2}
+		start = int(0)
+		end   = int(10)
+	)
+	convey.Convey("UppersPassedCache", t, func(ctx convey.C) {
+		aidm, err := d.UppersPassedCache(c, mids, start, end)
+		ctx.Convey("Then err should be nil.aidm should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+			ctx.So(aidm, convey.ShouldNotBeNil)
+		})
+	})
+}
+
+func TestArchiveExpireUpperPassedCache(t *testing.T) {
+	var (
+		c   = context.TODO()
+		mid = int64(1)
+	)
+	convey.Convey("ExpireUpperPassedCache", t, func(ctx convey.C) {
+		ok, err := d.ExpireUpperPassedCache(c, mid)
+		ctx.Convey("Then err should be nil.ok should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+			ctx.So(ok, convey.ShouldNotBeNil)
+		})
+	})
+}
+
+func TestArchiveExpireUppersCountCache(t *testing.T) {
+	var (
+		c    = context.TODO()
+		mids = []int64{1, 2}
+	)
+	convey.Convey("ExpireUppersCountCache", t, func(ctx convey.C) {
+		cachedUp, missed, err := d.ExpireUppersCountCache(c, mids)
+		ctx.Convey("Then err should be nil.cachedUp,missed should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+			ctx.So(missed, convey.ShouldNotBeNil)
+			ctx.So(cachedUp, convey.ShouldNotBeNil)
+		})
+	})
+}
+
+func TestArchiveExpireUppersPassedCache(t *testing.T) {
+	var (
+		c    = context.TODO()
+		mids = []int64{1, 2}
+	)
+	convey.Convey("ExpireUppersPassedCache", t, func(ctx convey.C) {
+		res, err := d.ExpireUppersPassedCache(c, mids)
+		ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+			ctx.So(res, convey.ShouldNotBeNil)
+		})
+	})
+}
+
+func TestArchiveAddUpperPassedCache(t *testing.T) {
+	var (
+		c          = context.TODO()
+		mid        = int64(1)
+		aids       = []int64{1}
+		ptimes     = []time.Time{1531553274}
+		copyrights = []int8{1}
+	)
+	convey.Convey("AddUpperPassedCache", t, func(ctx convey.C) {
+		err := d.AddUpperPassedCache(c, mid, aids, ptimes, copyrights)
+		ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestArchiveDelUpperPassedCache(t *testing.T) {
+	var (
+		c   = context.TODO()
+		mid = int64(1)
+		aid = int64(1)
+	)
+	convey.Convey("DelUpperPassedCache", t, func(ctx convey.C) {
+		err := d.DelUpperPassedCache(c, mid, aid)
+		ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}

app/service/main/up/dao/archive/upper_staff.go

@@ -0,0 +1,85 @@
+package archive
+
+import (
+	"context"
+	"fmt"
+
+	"go-common/library/database/sql"
+	"go-common/library/xstr"
+)
+
+const (
+	_staffSQL    = "SELECT aid FROM archive_staff WHERE staff_mid = ? AND state = 1"
+	_staffsSQL   = "SELECT aid, staff_mid FROM archive_staff WHERE staff_mid IN (%s) AND state = 1"
+	_staffAidSQL = "SELECT staff_mid FROM archive_staff WHERE aid = ? AND state = 1"
+)
+
+// Staff get upper staff aids by mid.
+func (d *Dao) Staff(c context.Context, mid int64) (aids []int64, err error) {
+	d.infoProm.Incr("Staff")
+	rows, err := d.archiveDB.Query(c, _staffSQL, mid)
+	if err != nil {
+		return
+	}
+	defer rows.Close()
+	for rows.Next() {
+		var aid int64
+		if err = rows.Scan(&aid); err != nil {
+			if err == sql.ErrNoRows {
+				err = nil
+				return
+			}
+			return
+		}
+		aids = append(aids, aid)
+	}
+	return
+}
+
+// Staffs get uppers staff aids by mids.
+func (d *Dao) Staffs(c context.Context, mids []int64) (aidm map[int64][]int64, err error) {
+	d.infoProm.Incr("Staffs")
+	rows, err := d.archiveDB.Query(c, fmt.Sprintf(_staffsSQL, xstr.JoinInts(mids)))
+	if err != nil {
+		return
+	}
+	defer rows.Close()
+	aidm = make(map[int64][]int64, len(mids))
+	for rows.Next() {
+		var (
+			aid      int64
+			staffMid int64
+		)
+		if err = rows.Scan(&aid, &staffMid); err != nil {
+			if err == sql.ErrNoRows {
+				err = nil
+				return
+			}
+			return
+		}
+		aidm[staffMid] = append(aidm[staffMid], aid)
+	}
+	return
+}
+
+// StaffAid get uppers staff mid-list by aid.
+func (d *Dao) StaffAid(c context.Context, aid int64) (mids []int64, err error) {
+	d.infoProm.Incr("StaffAid")
+	rows, err := d.archiveDB.Query(c, _staffAidSQL, aid)
+	if err != nil {
+		return
+	}
+	defer rows.Close()
+	for rows.Next() {
+		var mid int64
+		if err = rows.Scan(&mid); err != nil {
+			if err == sql.ErrNoRows {
+				err = nil
+				return
+			}
+			return
+		}
+		mids = append(mids, mid)
+	}
+	return
+}

app/service/main/up/dao/archive/upper_staff_test.go

@@ -0,0 +1,56 @@
+package archive
+
+import (
+	"context"
+	"testing"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestArchiveStaff(t *testing.T) {
+	convey.Convey("Staff", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			mid = int64(27515258)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			aids, err := d.Staff(c, mid)
+			ctx.Convey("Then err should be nil.aids should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(len(aids), convey.ShouldBeGreaterThanOrEqualTo, 0)
+			})
+		})
+	})
+}
+
+func TestArchiveStaffs(t *testing.T) {
+	convey.Convey("Staffs", t, func(ctx convey.C) {
+		var (
+			c    = context.Background()
+			mids = []int64{27515258}
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			aidm, err := d.Staffs(c, mids)
+			ctx.Convey("Then err should be nil.aidm should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(aidm, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestArchiveStaffAid(t *testing.T) {
+	convey.Convey("StaffAid", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			aid = int64(10110188)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			mids, err := d.StaffAid(c, aid)
+			ctx.Convey("Then err should be nil.mids should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(mids, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}

app/service/main/up/dao/archive/upper_test.go

@@ -0,0 +1,65 @@
+package archive
+
+import (
+	"context"
+	"testing"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestArchiveUppersCount(t *testing.T) {
+	var (
+		c    = context.TODO()
+		mids = []int64{1, 2}
+	)
+	convey.Convey("UppersCount", t, func(ctx convey.C) {
+		uc, err := d.UppersCount(c, mids)
+		ctx.Convey("Then err should be nil.uc should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+			ctx.So(uc, convey.ShouldNotBeNil)
+		})
+	})
+}
+
+func TestArchiveUpperCount(t *testing.T) {
+	var (
+		c   = context.TODO()
+		mid = int64(1)
+	)
+	convey.Convey("UpperCount", t, func(ctx convey.C) {
+		count, err := d.UpperCount(c, mid)
+		ctx.Convey("Then err should be nil.count should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+			ctx.So(count, convey.ShouldNotBeNil)
+		})
+	})
+}
+
+func TestArchiveUpperPassed(t *testing.T) {
+	var (
+		c   = context.TODO()
+		mid = int64(1)
+	)
+	convey.Convey("UpperPassed", t, func(ctx convey.C) {
+		_, _, _, err := d.UpperPassed(c, mid)
+		ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestArchiveUppersPassed(t *testing.T) {
+	var (
+		c    = context.TODO()
+		mids = []int64{1}
+	)
+	convey.Convey("UppersPassed", t, func(ctx convey.C) {
+		aidm, ptimes, copyrights, err := d.UppersPassed(c, mids)
+		ctx.Convey("Then err should be nil.aidm,ptimes,copyrights should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+			ctx.So(copyrights, convey.ShouldNotBeNil)
+			ctx.So(ptimes, convey.ShouldNotBeNil)
+			ctx.So(aidm, convey.ShouldNotBeNil)
+		})
+	})
+}