Create & Init Project...

app/job/main/app-player/BUILD

@@ -0,0 +1,21 @@
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [
+        ":package-srcs",
+        "//app/job/main/app-player/cmd:all-srcs",
+        "//app/job/main/app-player/conf:all-srcs",
+        "//app/job/main/app-player/dao:all-srcs",
+        "//app/job/main/app-player/http:all-srcs",
+        "//app/job/main/app-player/model:all-srcs",
+        "//app/job/main/app-player/service:all-srcs",
+    ],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

app/job/main/app-player/CHANGELOG.md

@@ -0,0 +1,5 @@
+### app-player job
+
+#### Version 1.0.0
+
+> 1.player订阅稿件变更

app/job/main/app-player/CONTRIBUTORS.md

@@ -0,0 +1,10 @@
+# Owner
+peiyifei
+liweijia
+
+# Author 
+luoxiaofan
+
+# Reviewer
+peiyifei
+haoguanwei

app/job/main/app-player/OWNERS

@@ -0,0 +1,16 @@
+# See the OWNERS docs at https://go.k8s.io/owners
+
+approvers:
+- liweijia
+- luoxiaofan
+- peiyifei
+labels:
+- job
+- job/main/app-player
+- main
+options:
+  no_parent_owners: true
+reviewers:
+- haoguanwei
+- luoxiaofan
+- peiyifei

app/job/main/app-player/README.md

@@ -0,0 +1,13 @@
+#### app-player-job
+
+##### 项目简介
+> 1.提供app-player缓存更新
+
+##### 编译环境
+> 请只用golang v1.8.x以上版本编译执行。  
+
+##### 依赖包
+> 1.公共包go-common  
+
+##### 特别说明
+> 1.model目录可能会被其他项目引用，请谨慎请改并通知各方。  

app/job/main/app-player/cmd/BUILD

@@ -0,0 +1,41 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_binary",
+    "go_library",
+)
+
+go_binary(
+    name = "cmd",
+    embed = [":go_default_library"],
+    tags = ["automanaged"],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["main.go"],
+    data = ["app-player-job-test.toml"],
+    importpath = "go-common/app/job/main/app-player/cmd",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/job/main/app-player/conf:go_default_library",
+        "//app/job/main/app-player/http:go_default_library",
+        "//library/log: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/job/main/app-player/cmd/app-player-job-test.toml

@@ -0,0 +1,38 @@
+[archiveNotifySub]
+key = "0QEO9F8JuuIxZzNDvklH"
+secret = "0QEO9F8JuuIxZzNDvklI"
+group = "ArchiveNotify-App-S"
+topic = "ArchiveNotify-T"
+action = "sub"
+name = "app-job/archiveNotifysub"
+proto = "tcp"
+addr = "172.16.33.158:6205"
+idle = 1
+active = 1
+dialTimeout = "1s"
+readTimeout = "60s"
+writeTimeout = "1s"
+idleTimeout = "10s"
+
+[memcache]
+    name   = "app-player-job/player"
+    proto  = "tcp"
+    addr   = "172.22.33.137:11218"
+    active = 50
+    idle   = 10
+    dialTimeout  = "50ms"
+    readTimeout  = "100ms"
+    writeTimeout = "100ms"
+    idleTimeout  = "80s"
+    expireArchive = "2h"
+
+[redis]
+    name   = "app-player-job/player"
+    proto  = "tcp"
+    addr   = "172.18.33.61:6807"
+    active = 20
+    idle   = 10
+    dialTimeout  = "50ms"
+    readTimeout  = "100ms"
+    writeTimeout = "100ms"
+    idleTimeout  = "80s"

app/job/main/app-player/cmd/main.go

@@ -0,0 +1,44 @@
+package main
+
+import (
+	"flag"
+	"os"
+	"os/signal"
+	"syscall"
+
+	"go-common/app/job/main/app-player/conf"
+	"go-common/app/job/main/app-player/http"
+	"go-common/library/log"
+)
+
+func main() {
+	flag.Parse()
+	if err := conf.Init(); err != nil {
+		log.Error("conf.Init() error(%v)", err)
+		panic(err)
+	}
+	log.Init(conf.Conf.XLog)
+	defer log.Close()
+	log.Info("app-player-job start")
+	http.Init(conf.Conf)
+	signalHandler()
+}
+
+func signalHandler() {
+	var (
+		ch = make(chan os.Signal, 1)
+	)
+	signal.Notify(ch, syscall.SIGHUP, syscall.SIGQUIT, syscall.SIGTERM, syscall.SIGINT)
+	for {
+		si := <-ch
+		switch si {
+		case syscall.SIGQUIT, syscall.SIGTERM, syscall.SIGINT:
+			log.Info("get a signal %s, stop the consume process", si.String())
+			http.Svc.Close()
+			return
+		case syscall.SIGHUP:
+		default:
+			return
+		}
+	}
+}

app/job/main/app-player/conf/BUILD

@@ -0,0 +1,38 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["conf.go"],
+    importpath = "go-common/app/job/main/app-player/conf",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//library/cache/memcache:go_default_library",
+        "//library/cache/redis:go_default_library",
+        "//library/conf:go_default_library",
+        "//library/log:go_default_library",
+        "//library/net/http/blademaster:go_default_library",
+        "//library/net/rpc:go_default_library",
+        "//library/queue/databus:go_default_library",
+        "//vendor/github.com/BurntSushi/toml: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/job/main/app-player/conf/conf.go

@@ -0,0 +1,100 @@
+package conf
+
+import (
+	"errors"
+	"flag"
+
+	"go-common/library/cache/memcache"
+	"go-common/library/cache/redis"
+	"go-common/library/conf"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/net/rpc"
+	"go-common/library/queue/databus"
+
+	"github.com/BurntSushi/toml"
+)
+
+// is
+var (
+	confPath string
+	client   *conf.Client
+	Conf     = &Config{}
+)
+
+// Config is
+type Config struct {
+	// Env
+	Env string
+	// interface XLog
+	XLog *log.Config
+	// databus
+	ArchiveNotifySub *databus.Config
+	// http
+	BM *bm.ServerConfig
+	// mc
+	Memcache *memcache.Config
+	// rpc client
+	ArchiveRPC *rpc.ClientConfig
+	// redis
+	Redis *redis.Config
+	// Custom 自定义启动参数
+	Custom *Custom
+}
+
+// Custom is
+type Custom struct {
+	Flush bool
+}
+
+func init() {
+	flag.StringVar(&confPath, "conf", "", "config path")
+}
+
+// Init init conf
+func Init() error {
+	if confPath != "" {
+		return local()
+	}
+	return remote()
+}
+
+func local() (err error) {
+	_, err = toml.DecodeFile(confPath, &Conf)
+	return
+}
+
+func remote() (err error) {
+	if client, err = conf.New(); err != nil {
+		return
+	}
+	if err = load(); err != nil {
+		return
+	}
+	client.Watch("app-player-job.toml")
+	go func() {
+		for range client.Event() {
+			log.Info("config reload")
+			if load() != nil {
+				log.Error("config reload error (%v)", err)
+			}
+		}
+	}()
+	return
+}
+
+func load() (err error) {
+	var (
+		s       string
+		ok      bool
+		tmpConf *Config
+	)
+	if s, ok = client.Toml2(); !ok {
+		return errors.New("load config center error")
+	}
+	if _, err = toml.Decode(s, &tmpConf); err != nil {
+		return errors.New("could not decode config")
+	}
+	*Conf = *tmpConf
+	return
+}

app/job/main/app-player/dao/BUILD

@@ -0,0 +1,56 @@
+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",
+        "redis_test.go",
+    ],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/app-player/model/archive:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "dao.go",
+        "memcache.go",
+        "redis.go",
+    ],
+    importpath = "go-common/app/job/main/app-player/dao",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/interface/main/app-player/model/archive:go_default_library",
+        "//app/job/main/app-player/conf:go_default_library",
+        "//library/cache/memcache:go_default_library",
+        "//library/cache/redis: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/job/main/app-player/dao/dao.go

@@ -0,0 +1,37 @@
+package dao
+
+import (
+	"context"
+
+	"go-common/app/job/main/app-player/conf"
+	"go-common/library/cache/memcache"
+	"go-common/library/cache/redis"
+)
+
+// Dao is dao.
+type Dao struct {
+	// mc
+	mc *memcache.Pool
+	// redis
+	redis *redis.Pool
+}
+
+// New new a dao.
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		// mc
+		mc: memcache.NewPool(c.Memcache),
+		// reids
+		redis: redis.NewPool(c.Redis),
+	}
+	return
+}
+
+// PingMc is
+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: 0}
+	err = conn.Set(item)
+	conn.Close()
+	return
+}

app/job/main/app-player/dao/dao_test.go

@@ -0,0 +1,24 @@
+package dao
+
+import (
+	"context"
+	"testing"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+var (
+	d *Dao
+)
+
+func TestPingMc(t *testing.T) {
+	var (
+		c = context.Background()
+	)
+	convey.Convey("Ping", t, func(ctx convey.C) {
+		err := d.PingMc(c)
+		ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}

app/job/main/app-player/dao/memcache.go

@@ -0,0 +1,31 @@
+package dao
+
+import (
+	"context"
+	"strconv"
+
+	"go-common/app/interface/main/app-player/model/archive"
+	"go-common/library/cache/memcache"
+
+	"github.com/pkg/errors"
+)
+
+const (
+	_prefixArc = "p_"
+)
+
+func keyArc(aid int64) string {
+	return _prefixArc + strconv.FormatInt(aid, 10)
+}
+
+// AddArchiveCache add archive cache.
+func (d *Dao) AddArchiveCache(c context.Context, aid int64, arc *archive.Info) (err error) {
+	conn := d.mc.Get(c)
+	key := keyArc(aid)
+	item := &memcache.Item{Key: key, Object: arc, Flags: memcache.FlagProtobuf, Expiration: 0}
+	if err = conn.Set(item); err != nil {
+		err = errors.Wrapf(err, "conn.Set(%v)", item)
+	}
+	conn.Close()
+	return
+}

app/job/main/app-player/dao/memcache_test.go

@@ -0,0 +1,24 @@
+package dao
+
+import (
+	"context"
+	"testing"
+
+	"go-common/app/interface/main/app-player/model/archive"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestAddArchiveCache(t *testing.T) {
+	var (
+		c   = context.Background()
+		aid = int64(1)
+		arc = &archive.Info{Aid: 1}
+	)
+	convey.Convey("AddArchiveCache", t, func(ctx convey.C) {
+		err := d.AddArchiveCache(c, aid, arc)
+		ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}

app/job/main/app-player/dao/redis.go

@@ -0,0 +1,55 @@
+package dao
+
+import (
+	"context"
+	"encoding/json"
+
+	"go-common/library/cache/redis"
+
+	"github.com/pkg/errors"
+)
+
+const (
+	_failList = "player_job_list"
+)
+
+func keyRetry() string {
+	return _failList
+}
+
+// PushList rpush item to redis
+func (d *Dao) PushList(c context.Context, a interface{}) (err error) {
+	var bs []byte
+	conn := d.redis.Get(c)
+	defer conn.Close()
+	if bs, err = json.Marshal(a); err != nil {
+		err = errors.Wrapf(err, "%v", a)
+		return
+	}
+	if _, err = conn.Do("RPUSH", keyRetry(), bs); err != nil {
+		err = errors.Wrapf(err, "conn.Do(RPUSH,%s,%s)", keyRetry(), bs)
+	}
+	return
+}
+
+// PopList lpop item from redis
+func (d *Dao) PopList(c context.Context) (bs []byte, err error) {
+	conn := d.redis.Get(c)
+	if bs, err = redis.Bytes(conn.Do("LPOP", keyRetry())); err != nil {
+		if err == redis.ErrNil {
+			err = nil
+		} else {
+			err = errors.Wrapf(err, "redis.Bytes(conn.Do(LPOP, %s))", keyRetry())
+		}
+	}
+	conn.Close()
+	return
+}
+
+// PingRedis is
+func (d *Dao) PingRedis(c context.Context) (err error) {
+	var conn = d.redis.Get(c)
+	_, err = conn.Do("SET", "PING", "PONG")
+	conn.Close()
+	return
+}

app/job/main/app-player/dao/redis_test.go

@@ -0,0 +1,44 @@
+package dao
+
+import (
+	"context"
+	"testing"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestPushList(t *testing.T) {
+	var (
+		c = context.Background()
+	)
+	convey.Convey("PushList", t, func(ctx convey.C) {
+		err := d.PushList(c, nil)
+		ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestPopList(t *testing.T) {
+	var (
+		c = context.Background()
+	)
+	convey.Convey("PopList", t, func(ctx convey.C) {
+		_, err := d.PopList(c)
+		ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestPingRedis(t *testing.T) {
+	var (
+		c = context.Background()
+	)
+	convey.Convey("PingRedis", t, func(ctx convey.C) {
+		err := d.PingRedis(c)
+		ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}

app/job/main/app-player/http/BUILD

@@ -0,0 +1,34 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["http.go"],
+    importpath = "go-common/app/job/main/app-player/http",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/job/main/app-player/conf:go_default_library",
+        "//app/job/main/app-player/service:go_default_library",
+        "//library/log:go_default_library",
+        "//library/net/http/blademaster: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/job/main/app-player/http/http.go

@@ -0,0 +1,45 @@
+package http
+
+import (
+	"net/http"
+
+	"go-common/app/job/main/app-player/conf"
+	"go-common/app/job/main/app-player/service"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+)
+
+// is
+var (
+	Svc *service.Service
+)
+
+// Init init http
+func Init(c *conf.Config) {
+	initService(c)
+	// init external router
+	engineIn := bm.DefaultServer(c.BM)
+	innerRouter(engineIn)
+	// init Inner server
+	if err := engineIn.Start(); err != nil {
+		log.Error("bm.DefaultServer error(%v)", err)
+		panic(err)
+	}
+}
+
+func initService(c *conf.Config) {
+	Svc = service.New(c)
+}
+
+// innerRouter init inner router api path.
+func innerRouter(e *bm.Engine) {
+	e.Ping(ping)
+}
+
+func ping(c *bm.Context) {
+	err := Svc.Ping(c)
+	if err != nil {
+		log.Error("app-player-job service ping error(%+v)", err)
+		c.AbortWithStatus(http.StatusServiceUnavailable)
+	}
+}

app/job/main/app-player/model/BUILD

@@ -0,0 +1,31 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "model.go",
+        "retry.go",
+    ],
+    importpath = "go-common/app/job/main/app-player/model",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

app/job/main/app-player/model/model.go

@@ -0,0 +1,17 @@
+package model
+
+import (
+	"encoding/json"
+)
+
+// Message is
+type Message struct {
+	Action string          `json:"action"`
+	Table  string          `json:"table"`
+	New    json.RawMessage `json:"new"`
+}
+
+// ArcMsg is
+var ArcMsg struct {
+	Aid int64 `json:"aid"`
+}

app/job/main/app-player/model/retry.go

@@ -0,0 +1,6 @@
+package model
+
+// Retry is
+type Retry struct {
+	Aid int64 `json:"aid"`
+}

app/job/main/app-player/service/BUILD

@@ -0,0 +1,51 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_test",
+    "go_library",
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["service_test.go"],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/job/main/app-player/conf:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["service.go"],
+    importpath = "go-common/app/job/main/app-player/service",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/interface/main/app-player/model/archive:go_default_library",
+        "//app/job/main/app-player/conf:go_default_library",
+        "//app/job/main/app-player/dao:go_default_library",
+        "//app/job/main/app-player/model:go_default_library",
+        "//app/service/main/archive/api:go_default_library",
+        "//library/ecode:go_default_library",
+        "//library/log:go_default_library",
+        "//library/queue/databus: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/job/main/app-player/service/service.go

@@ -0,0 +1,175 @@
+package service
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"sync"
+	"time"
+
+	appmdl "go-common/app/interface/main/app-player/model/archive"
+	"go-common/app/job/main/app-player/conf"
+	"go-common/app/job/main/app-player/dao"
+	"go-common/app/job/main/app-player/model"
+	arcrpc "go-common/app/service/main/archive/api"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	"go-common/library/queue/databus"
+)
+
+const (
+	_updateAct    = "update"
+	_insertAct    = "insert"
+	_tableArchive = "archive"
+)
+
+// Service is service.
+type Service struct {
+	c      *conf.Config
+	dao    *dao.Dao
+	arcRPC arcrpc.ArchiveClient
+	// sub
+	archiveNotifySub *databus.Databus
+	waiter           sync.WaitGroup
+	closed           bool
+}
+
+// New new a service.
+func New(c *conf.Config) (s *Service) {
+	s = &Service{
+		c:                c,
+		dao:              dao.New(c),
+		archiveNotifySub: databus.New(c.ArchiveNotifySub),
+		closed:           false,
+	}
+	var err error
+	s.arcRPC, err = arcrpc.NewClient(nil)
+	if err != nil {
+		panic(fmt.Sprintf("archive NewClient error(%v)", err))
+	}
+	s.waiter.Add(1)
+	go s.arcConsumeproc()
+	s.waiter.Add(1)
+	go s.retryproc()
+	return
+}
+
+// Close Databus consumer close.
+func (s *Service) Close() {
+	s.closed = true
+	s.archiveNotifySub.Close()
+	s.waiter.Wait()
+}
+
+// Ping is
+func (s *Service) Ping(c context.Context) (err error) {
+	if err = s.dao.PingMc(c); err != nil {
+		return
+	}
+	return
+}
+
+// arcConsumeproc consumer archive
+func (s *Service) arcConsumeproc() {
+	var (
+		msg *databus.Message
+		ok  bool
+		err error
+	)
+	msgs := s.archiveNotifySub.Messages()
+	for {
+		if msg, ok = <-msgs; !ok {
+			log.Info("arc databus Consumer exit")
+			break
+		}
+		log.Info("got databus message(%s)", msg.Value)
+		msg.Commit()
+		var ms = &model.Message{}
+		if err = json.Unmarshal(msg.Value, ms); err != nil {
+			log.Error("json.Unmarshal(%s) error(%v)", msg.Value, err)
+			continue
+		}
+		switch ms.Table {
+		case _tableArchive:
+			s.archiveUpdate(ms.Action, ms.New)
+		}
+	}
+	s.waiter.Done()
+}
+
+func (s *Service) archiveUpdate(action string, nwMsg []byte) {
+	nw := &model.ArcMsg
+	if err := json.Unmarshal(nwMsg, nw); err != nil {
+		log.Error("json.Unmarshal(%s) error(%v)", nwMsg, err)
+		return
+	}
+	switch action {
+	case _updateAct, _insertAct:
+		s.upArcCache(nw.Aid)
+	}
+}
+
+func (s *Service) upArcCache(aid int64) {
+	var (
+		view *arcrpc.ViewReply
+		arc  *appmdl.Info
+		cids []int64
+		err  error
+	)
+	defer func() {
+		if err != nil {
+			retry := &model.Retry{Aid: aid}
+			s.dao.PushList(context.Background(), retry)
+			log.Warn("upArcCache fail(%+v)", retry)
+		}
+	}()
+	c := context.Background()
+	if view, err = s.arcRPC.View(c, &arcrpc.ViewRequest{Aid: aid}); err != nil {
+		if ecode.Cause(err).Equal(ecode.NothingFound) {
+			err = nil
+			return
+		}
+		log.Error("s.arcRPC.View3(%d) error(%v)", aid, err)
+		return
+	}
+	for _, p := range view.Pages {
+		cids = append(cids, p.Cid)
+	}
+	arc = &appmdl.Info{
+		Aid:       aid,
+		Cids:      cids,
+		State:     view.Arc.State,
+		Mid:       view.Arc.Author.Mid,
+		Attribute: view.Arc.Attribute,
+	}
+	if err = s.dao.AddArchiveCache(context.Background(), aid, arc); err == nil {
+		log.Info("update view cahce aid(%d) success", aid)
+	}
+}
+
+func (s *Service) retryproc() {
+	for {
+		if s.closed {
+			break
+		}
+		var (
+			retry = &model.Retry{}
+			bs    []byte
+			err   error
+		)
+		if bs, err = s.dao.PopList(context.Background()); err != nil || len(bs) == 0 {
+			time.Sleep(5 * time.Second)
+			continue
+		}
+		if err = json.Unmarshal(bs, retry); err != nil {
+			log.Error("json.Unmarshal(%s) error(%v)", bs, err)
+			continue
+		}
+		log.Info("retry data(%+v) start", retry)
+		if retry.Aid != 0 {
+			s.upArcCache(retry.Aid)
+		}
+		log.Info("retry data(%+v) end", retry)
+	}
+	s.waiter.Done()
+}

app/job/main/app-player/service/service_test.go

@@ -0,0 +1,63 @@
+package service
+
+import (
+	"context"
+	"go-common/app/job/main/app-player/conf"
+	"testing"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+func TestNew(t *testing.T) {
+	type args struct {
+		c *conf.Config
+	}
+	tests := []struct {
+		name  string
+		args  args
+		wantS *Service
+	}{
+	// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		Convey(tt.name, t, func(t *testing.T) {
+			gotS := New(tt.args.c)
+			So(gotS, ShouldEqual, tt.wantS)
+		})
+	}
+}
+
+func TestService_Close(t *testing.T) {
+	tests := []struct {
+		name string
+		s    *Service
+	}{
+	// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			tt.s.Close()
+		})
+	}
+}
+
+func TestService_Ping(t *testing.T) {
+	type args struct {
+		c context.Context
+	}
+	tests := []struct {
+		name    string
+		s       *Service
+		args    args
+		wantErr bool
+	}{
+	// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if err := tt.s.Ping(tt.args.c); (err != nil) != tt.wantErr {
+				t.Errorf("Service.Ping() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}