Create & Init Project...

app/job/live-userexp/BUILD

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

app/job/live-userexp/CHANGELOG.MD

@@ -0,0 +1,7 @@
+### userexp-live service
+
+#### Version 1.0.1
+1. waitgroup
+
+#### Version 1.0.0
+> 1. 新增服务模块

app/job/live-userexp/CONTRIBUTORS.MD

@@ -0,0 +1,9 @@
+# Owner
+zhapuyu
+lixiang
+
+# Author
+lixiang
+
+# Reviewer
+zhapuyu

app/job/live-userexp/OWNERS

@@ -0,0 +1,11 @@
+# See the OWNERS docs at https://go.k8s.io/owners
+
+approvers:
+- lidongyang
+- liuzhen
+- xiehaishen
+- yangbaibing
+- zhaohailin
+labels:
+- job
+- live

app/job/live-userexp/README.md

@@ -0,0 +1,8 @@
+#### userexp-live service
+从直播用户服务中抽离出的单元数据模块、负责用户经验查询、存储。
+
+##### 依赖环境
+Go 1.7.5或更高版本
+
+##### API文档
+TODO example code api

app/job/live-userexp/cmd/BUILD

@@ -0,0 +1,41 @@
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+    "go_binary",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["main.go"],
+    data = ["live-userexp-job-example.toml"],
+    importpath = "go-common/app/job/live-userexp/cmd",
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+    deps = [
+        "//app/job/live-userexp/conf:go_default_library",
+        "//app/job/live-userexp/model:go_default_library",
+        "//app/job/live-userexp/service:go_default_library",
+        "//library/log:go_default_library",
+        "//library/syscall:go_default_library",
+    ],
+)
+
+go_binary(
+    name = "cmd",
+    embed = [":go_default_library"],
+    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/live-userexp/cmd/live-userexp-job-example.toml

@@ -0,0 +1,58 @@
+# This is a TOML document. Boom.
+
+version = "1.0.0"
+user = "root"
+pid = "/tmp/live-userexp-job.pid"
+dir = "./"
+perf = "0.0.0.0:20102"
+family = "live-userexp-job"
+env = dev
+
+[log]
+    dir = "/data/log/live-userexp-job"
+
+[db]
+    [db.exp]
+    addr = "172.16.33.69:3306"
+    dsn = "live:oWni@ElNs0P0C(dphdj*F1y4@tcp(172.16.33.69:3306)/live_user_exp?timeout=5s&readTimeout=30s&writeTimeout=5s&parseTime=true&loc=Local&charset=utf8,utf8mb4"
+    active = 5
+    idle = 5
+    queryTimeout = "1s"
+    execTimeout = "1s"
+    tranTimeout = "2s"
+    [db.exp.breaker]
+    window = "3s"
+    sleep = "100ms"
+    bucket = 10
+    ratio = 0.5
+    request = 100
+
+[memcache]
+levelExpire = 86400
+    [memcache.exp]
+    name = "live-userexp-service/exp"
+    proto = "tcp"
+    addr = "172.16.33.251:11211"
+    idle = 5
+    active = 10
+    dialTimeout = "1s"
+    readTimeout = "1s"
+    writeTimeout = "1s"
+    idleTimeout = "80s"
+
+[expSub]
+key = "ec4c0820d525d67b"
+secret = "2bdf3bd4ecab041b5d5640a1da4f7f81"
+group = "LiveUserExpBinlog-LiveLive-S"
+topic = "LiveUserExpBinlog-T"
+action = "sub"
+offset = "new"
+name = "liveuser-job/exp-sub"
+proto = "tcp"
+addr = "172.16.33.158:6205"
+idle = 100
+active = 100
+dialTimeout = "1s"
+readTimeout = "60s"
+writeTimeout = "1s"
+idleTimeout = "10s"

app/job/live-userexp/cmd/main.go

@@ -0,0 +1,47 @@
+package main
+
+import (
+	"flag"
+	"os"
+	"os/signal"
+
+	"go-common/app/job/live-userexp/conf"
+	_ "go-common/app/job/live-userexp/model"
+	"go-common/app/job/live-userexp/service"
+	"go-common/library/log"
+	"go-common/library/syscall"
+)
+
+func main() {
+	flag.Parse()
+	if err := conf.Init(); err != nil {
+		log.Error("conf.Init() error(%v)", err)
+		panic(err)
+	}
+	// init log
+	log.Init(conf.Conf.Log)
+	log.Info("search-job start")
+	defer log.Close()
+
+	// service init
+	srv := service.New(conf.Conf)
+
+	// init signal
+	c := make(chan os.Signal, 1)
+	signal.Notify(c, syscall.SIGHUP, syscall.SIGQUIT, syscall.SIGTERM, syscall.SIGINT, syscall.SIGSTOP)
+	for {
+		s := <-c
+		log.Info("live-userexp-job get a signal %s", s.String())
+		switch s {
+		case syscall.SIGQUIT, syscall.SIGTERM, syscall.SIGSTOP, syscall.SIGINT:
+			log.Info("live-userexp-job exit")
+			srv.Close()
+			return
+		case syscall.SIGHUP:
+			log.Info("TODO: reload for syscall.SIGHUP")
+			return
+		default:
+			return
+		}
+	}
+}

app/job/live-userexp/conf/BUILD

@@ -0,0 +1,35 @@
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["conf.go"],
+    importpath = "go-common/app/job/live-userexp/conf",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//library/cache/memcache:go_default_library",
+        "//library/conf:go_default_library",
+        "//library/database/sql:go_default_library",
+        "//library/log:go_default_library",
+        "//library/queue/databus:go_default_library",
+        "//library/time: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/live-userexp/conf/conf.go

@@ -0,0 +1,97 @@
+package conf
+
+import (
+	"errors"
+	"flag"
+
+	"go-common/library/cache/memcache"
+	"go-common/library/conf"
+	"go-common/library/database/sql"
+	"go-common/library/log"
+	"go-common/library/queue/databus"
+	"go-common/library/time"
+
+	"github.com/BurntSushi/toml"
+)
+
+// Conf global variable.
+var (
+	Conf     = &Config{}
+	client   *conf.Client
+	confPath string
+)
+
+// Config struct of conf.
+type Config struct {
+	// base
+	// log
+	Log *log.Config
+	// db
+	DB *DB
+	// mc
+	Memcache    *Memcache
+	LevelExpire int32
+	// databus
+	ExpSub *databus.Config
+	// Env
+	Env string
+}
+
+// DB db config.
+type DB struct {
+	Exp *sql.Config
+}
+
+// Memcache config
+type Memcache struct {
+	Exp       *memcache.Config
+	ExpExpire time.Duration
+}
+
+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
+	}
+	go func() {
+		for range client.Event() {
+			log.Info("config event")
+		}
+	}()
+	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
+}
+
+func init() {
+	flag.StringVar(&confPath, "conf", "", "default config path")
+}
+
+// Init int config
+func Init() error {
+	if confPath != "" {
+		return local()
+	}
+	return remote()
+}

app/job/live-userexp/dao/BUILD

@@ -0,0 +1,51 @@
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+    "go_test",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "dao.go",
+        "mc_level.go",
+    ],
+    importpath = "go-common/app/job/live-userexp/dao",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/job/live-userexp/conf:go_default_library",
+        "//app/job/live-userexp/model:go_default_library",
+        "//library/cache/memcache:go_default_library",
+        "//library/database/sql:go_default_library",
+        "//library/log:go_default_library",
+    ],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["mc_level_test.go"],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/job/live-userexp/conf:go_default_library",
+        "//app/job/live-userexp/model:go_default_library",
+        "//library/log:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey: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/live-userexp/dao/dao.go

@@ -0,0 +1,69 @@
+package dao
+
+import (
+	"context"
+
+	"go-common/app/job/live-userexp/conf"
+	"go-common/library/cache/memcache"
+	"go-common/library/database/sql"
+	"go-common/library/log"
+)
+
+// Dao struct userexp-service dao
+type Dao struct {
+	c *conf.Config
+	// exp db
+	expDb *sql.DB
+	// memcache
+	expMc       *memcache.Pool
+	cacheExpire int32
+}
+
+// New new a Dao and return.
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		c:           c,
+		expDb:       sql.NewMySQL(c.DB.Exp),
+		expMc:       memcache.NewPool(c.Memcache.Exp),
+		cacheExpire: c.LevelExpire,
+	}
+	return
+}
+
+// Ping check service health.
+func (d *Dao) Ping(c context.Context) (err error) {
+	if err = d.expDb.Ping(c); err != nil {
+		log.Error("PingDb error(%v)", err)
+		return
+	}
+	if err = d.pingMemcache(c); err != nil {
+		return
+	}
+	return
+}
+
+// PingMemcache check connection success.
+func (d *Dao) pingMemcache(c context.Context) (err error) {
+	item := &memcache.Item{
+		Key:        "ping",
+		Value:      []byte{1},
+		Expiration: d.cacheExpire,
+	}
+	conn := d.expMc.Get(c)
+	err = conn.Set(item)
+	conn.Close()
+	if err != nil {
+		log.Error("PingMemcache conn.Set(%v) error(%v)", item, err)
+	}
+	return
+}
+
+// Close close memcache resource.
+func (d *Dao) Close() {
+	if d.expMc != nil {
+		d.expMc.Close()
+	}
+	if d.expDb != nil {
+		d.expDb.Close()
+	}
+}

app/job/live-userexp/dao/mc_level.go

@@ -0,0 +1,35 @@
+package dao
+
+import (
+	"context"
+	"fmt"
+
+	"go-common/app/job/live-userexp/model"
+	mc "go-common/library/cache/memcache"
+	"go-common/library/log"
+)
+
+const (
+	_expKey = "level:%d"
+)
+
+func key(uid int64) string {
+	return fmt.Sprintf(_expKey, uid)
+}
+
+// SetLevelCache 设置等级缓存
+func (d *Dao) SetLevelCache(c context.Context, level *model.Level) (err error) {
+	key := key(level.Uid)
+	conn := d.expMc.Get(c)
+	defer conn.Close()
+
+	if conn.Set(&mc.Item{
+		Key:        key,
+		Object:     level,
+		Flags:      mc.FlagProtobuf,
+		Expiration: d.cacheExpire,
+	}); err != nil {
+		log.Error("[dao.mc_exp|SetLevelCache] conn.Set(%s, %v) error(%v)", key, level, err)
+	}
+	return
+}

app/job/live-userexp/dao/mc_level_test.go

@@ -0,0 +1,42 @@
+package dao
+
+import (
+	"context"
+	"sync"
+	"testing"
+	"time"
+
+	"go-common/app/job/live-userexp/conf"
+	"go-common/app/job/live-userexp/model"
+	"go-common/library/log"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+var (
+	once sync.Once
+	d    *Dao
+	ctx  = context.TODO()
+)
+
+func initConf() {
+	if err := conf.Init(); err != nil {
+		panic(err)
+	}
+	log.Init(conf.Conf.Log)
+	defer log.Close()
+}
+
+func startService() {
+	initConf()
+	d = New(conf.Conf)
+	time.Sleep(time.Second * 2)
+}
+
+func TestSetLevelCache(t *testing.T) {
+	Convey("SetLevelCache", t, func() {
+		once.Do(startService)
+		err := d.SetLevelCache(ctx, &model.Level{Uid: 10001, Uexp: 1000, Rexp: 100, Ulevel: 2, Rlevel: 1, Color: 12345})
+		So(err, ShouldBeNil)
+	})
+}

app/job/live-userexp/model/BUILD

@@ -0,0 +1,56 @@
+load(
+    "@io_bazel_rules_go//proto:def.bzl",
+    "go_proto_library",
+)
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "exp.go",
+        "model.go",
+    ],
+    embed = [":model_go_proto"],
+    importpath = "go-common/app/job/live-userexp/model",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "@com_github_gogo_protobuf//gogoproto:go_default_library",
+        "@com_github_golang_protobuf//proto: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"],
+)
+
+proto_library(
+    name = "model_proto",
+    srcs = ["exp.proto"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = ["@gogo_special_proto//github.com/gogo/protobuf/gogoproto"],
+)
+
+go_proto_library(
+    name = "model_go_proto",
+    compilers = ["@io_bazel_rules_go//proto:gogofast_proto"],
+    importpath = "go-common/app/job/live-userexp/model",
+    proto = ":model_proto",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = ["@com_github_gogo_protobuf//gogoproto:go_default_library"],
+)

app/job/live-userexp/model/exp.go

@@ -0,0 +1,167 @@
+package model
+
+const (
+	_MasterLevelMax = int32(40)
+	_UserLevelMax   = int32(60)
+
+	_ColorLevel1 = int32(9868950)
+	_ColorLevel2 = int32(6406234)
+	_ColorLevel3 = int32(5805790)
+	_ColorLevel4 = int32(9868950)
+)
+
+var (
+	_masterLevelMap = []int64{
+		0,           // 0
+		5000,        // 1
+		20000,       // 2
+		47000,       // 3
+		92000,       // 4
+		210000,      // 5
+		406000,      // 6
+		716000,      // 7
+		1176000,     // 8
+		1806000,     // 9
+		2716000,     // 10
+		3961000,     // 11
+		5641000,     // 12
+		7881000,     // 13
+		10981000,    // 14
+		15481000,    // 15
+		22681000,    // 16
+		31981000,    // 17
+		44281000,    // 18
+		60281000,    // 19
+		81681000,    // 20
+		113881000,   // 21
+		159481000,   // 22
+		221481000,   // 23
+		300481000,   // 24
+		398481000,   // 25
+		522981000,   // 26
+		690981000,   // 27
+		901381000,   // 28
+		1188381000,  // 29
+		1561381000,  // 30
+		2061381000,  // 31
+		2731381000,  // 32
+		3641381000,  // 33
+		4781381000,  // 34
+		6201381000,  // 35
+		7951381000,  // 36
+		9951381000,  // 37
+		12201381000, // 38
+		14701381000, // 39
+	}
+
+	_userLevelMap = []int64{
+		100000,     // 0
+		200000,     // 1
+		300000,     // 2
+		400000,     // 3
+		500000,     // 4
+		600000,     // 5
+		700000,     // 6
+		800000,     // 7
+		900000,     // 8
+		1000000,    // 9
+		1800000,    // 10
+		2600000,    // 11
+		3400000,    // 12
+		4200000,    // 13
+		5000000,    // 14
+		6000000,    // 15
+		7000000,    // 16
+		8000000,    // 17
+		9000000,    // 18
+		10000000,   // 19
+		18000000,   // 20
+		26000000,   // 21
+		34000000,   // 22
+		42000000,   // 23
+		50000000,   // 24
+		60000000,   // 25
+		70000000,   // 26
+		80000000,   // 27
+		90000000,   // 28
+		100000000,  // 29
+		110000000,  // 30
+		120000000,  // 31
+		130000000,  // 32
+		140000000,  // 33
+		150000000,  // 34
+		180000000,  // 35
+		210000000,  // 36
+		240000000,  // 37
+		270000000,  // 38
+		300000000,  // 39
+		340000000,  // 40
+		380000000,  // 41
+		420000000,  // 42
+		460000000,  // 43
+		500000000,  // 44
+		550000000,  // 45
+		600000000,  // 46
+		700000000,  // 47
+		800000000,  // 48
+		1000000000, // 49
+		1200000000, // 50
+		1400000000, // 51
+		1600000000, // 52
+		1800000000, // 53
+		2000000000, // 54
+		2200000000, // 55
+		2400000000, // 56
+		2600000000, // 57
+		2800000000, // 58
+		3000000000, // 59
+		4000000000, // 60
+	}
+)
+
+// FormatLevel 计算等级
+func FormatLevel(exp *Exp) (level *Level) {
+	level = &Level{Uid: exp.Uid, Uexp: exp.Uexp, Rexp: exp.Rexp, Ulevel: -1, Rlevel: -1, Color: 0}
+	level.Uid = exp.Uid
+	level.Uexp = exp.Uexp
+	level.Rexp = exp.Rexp
+
+	// 主播等级
+	for rlevel, v := range _masterLevelMap {
+		if exp.Rexp < v {
+			level.Rlevel = int32(rlevel)
+			level.Rnext = v - exp.Rexp
+			break
+		}
+	}
+	if level.Rlevel == -1 {
+		level.Rlevel = _MasterLevelMax
+	}
+
+	// 用户等级
+	for ulevel, v := range _userLevelMap {
+		if exp.Uexp < v {
+			level.Ulevel = int32(ulevel)
+			level.Unext = v - exp.Uexp
+			break
+		}
+	}
+	if level.Ulevel == -1 {
+		level.Ulevel = _UserLevelMax
+	}
+
+	// 等级颜色
+	switch {
+	case level.Ulevel <= 10:
+		level.Color = _ColorLevel1
+	case level.Ulevel <= 20:
+		level.Color = _ColorLevel2
+	case level.Ulevel <= 40:
+		level.Color = _ColorLevel3
+	case level.Ulevel < 50:
+		level.Color = _ColorLevel4
+	default:
+		level.Color = _ColorLevel4
+	}
+	return
+}

app/job/live-userexp/model/exp.pb.go

@@ -0,0 +1,735 @@
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
+// source: exp.proto
+
+/*
+	Package model is a generated protocol buffer package.
+
+	It is generated from these files:
+		exp.proto
+
+	It has these top-level messages:
+		Exp
+		Level
+*/
+package model
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+import _ "github.com/gogo/protobuf/gogoproto"
+
+import io "io"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
+
+type Exp struct {
+	Uid  int64 `protobuf:"varint,1,opt,name=Uid,proto3" json:"uid"`
+	Uexp int64 `protobuf:"varint,2,opt,name=Uexp,proto3" json:"uexp"`
+	Rexp int64 `protobuf:"varint,3,opt,name=Rexp,proto3" json:"rexp"`
+}
+
+func (m *Exp) Reset()                    { *m = Exp{} }
+func (m *Exp) String() string            { return proto.CompactTextString(m) }
+func (*Exp) ProtoMessage()               {}
+func (*Exp) Descriptor() ([]byte, []int) { return fileDescriptorExp, []int{0} }
+
+func (m *Exp) GetUid() int64 {
+	if m != nil {
+		return m.Uid
+	}
+	return 0
+}
+
+func (m *Exp) GetUexp() int64 {
+	if m != nil {
+		return m.Uexp
+	}
+	return 0
+}
+
+func (m *Exp) GetRexp() int64 {
+	if m != nil {
+		return m.Rexp
+	}
+	return 0
+}
+
+type Level struct {
+	Uid    int64 `protobuf:"varint,1,opt,name=Uid,proto3" json:"uid"`
+	Uexp   int64 `protobuf:"varint,2,opt,name=Uexp,proto3" json:"uexp"`
+	Rexp   int64 `protobuf:"varint,3,opt,name=Rexp,proto3" json:"rexp"`
+	Ulevel int32 `protobuf:"varint,4,opt,name=Ulevel,proto3" json:"ulevel"`
+	Rlevel int32 `protobuf:"varint,5,opt,name=Rlevel,proto3" json:"rlevel"`
+	Color  int32 `protobuf:"varint,6,opt,name=Color,proto3" json:"color"`
+	Unext  int64 `protobuf:"varint,7,opt,name=Unext,proto3" json:"unext"`
+	Rnext  int64 `protobuf:"varint,8,opt,name=Rnext,proto3" json:"rnext"`
+}
+
+func (m *Level) Reset()                    { *m = Level{} }
+func (m *Level) String() string            { return proto.CompactTextString(m) }
+func (*Level) ProtoMessage()               {}
+func (*Level) Descriptor() ([]byte, []int) { return fileDescriptorExp, []int{1} }
+
+func (m *Level) GetUid() int64 {
+	if m != nil {
+		return m.Uid
+	}
+	return 0
+}
+
+func (m *Level) GetUexp() int64 {
+	if m != nil {
+		return m.Uexp
+	}
+	return 0
+}
+
+func (m *Level) GetRexp() int64 {
+	if m != nil {
+		return m.Rexp
+	}
+	return 0
+}
+
+func (m *Level) GetUlevel() int32 {
+	if m != nil {
+		return m.Ulevel
+	}
+	return 0
+}
+
+func (m *Level) GetRlevel() int32 {
+	if m != nil {
+		return m.Rlevel
+	}
+	return 0
+}
+
+func (m *Level) GetColor() int32 {
+	if m != nil {
+		return m.Color
+	}
+	return 0
+}
+
+func (m *Level) GetUnext() int64 {
+	if m != nil {
+		return m.Unext
+	}
+	return 0
+}
+
+func (m *Level) GetRnext() int64 {
+	if m != nil {
+		return m.Rnext
+	}
+	return 0
+}
+
+func init() {
+	proto.RegisterType((*Exp)(nil), "model.Exp")
+	proto.RegisterType((*Level)(nil), "model.Level")
+}
+func (m *Exp) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *Exp) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if m.Uid != 0 {
+		dAtA[i] = 0x8
+		i++
+		i = encodeVarintExp(dAtA, i, uint64(m.Uid))
+	}
+	if m.Uexp != 0 {
+		dAtA[i] = 0x10
+		i++
+		i = encodeVarintExp(dAtA, i, uint64(m.Uexp))
+	}
+	if m.Rexp != 0 {
+		dAtA[i] = 0x18
+		i++
+		i = encodeVarintExp(dAtA, i, uint64(m.Rexp))
+	}
+	return i, nil
+}
+
+func (m *Level) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *Level) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if m.Uid != 0 {
+		dAtA[i] = 0x8
+		i++
+		i = encodeVarintExp(dAtA, i, uint64(m.Uid))
+	}
+	if m.Uexp != 0 {
+		dAtA[i] = 0x10
+		i++
+		i = encodeVarintExp(dAtA, i, uint64(m.Uexp))
+	}
+	if m.Rexp != 0 {
+		dAtA[i] = 0x18
+		i++
+		i = encodeVarintExp(dAtA, i, uint64(m.Rexp))
+	}
+	if m.Ulevel != 0 {
+		dAtA[i] = 0x20
+		i++
+		i = encodeVarintExp(dAtA, i, uint64(m.Ulevel))
+	}
+	if m.Rlevel != 0 {
+		dAtA[i] = 0x28
+		i++
+		i = encodeVarintExp(dAtA, i, uint64(m.Rlevel))
+	}
+	if m.Color != 0 {
+		dAtA[i] = 0x30
+		i++
+		i = encodeVarintExp(dAtA, i, uint64(m.Color))
+	}
+	if m.Unext != 0 {
+		dAtA[i] = 0x38
+		i++
+		i = encodeVarintExp(dAtA, i, uint64(m.Unext))
+	}
+	if m.Rnext != 0 {
+		dAtA[i] = 0x40
+		i++
+		i = encodeVarintExp(dAtA, i, uint64(m.Rnext))
+	}
+	return i, nil
+}
+
+func encodeVarintExp(dAtA []byte, offset int, v uint64) int {
+	for v >= 1<<7 {
+		dAtA[offset] = uint8(v&0x7f | 0x80)
+		v >>= 7
+		offset++
+	}
+	dAtA[offset] = uint8(v)
+	return offset + 1
+}
+func (m *Exp) Size() (n int) {
+	var l int
+	_ = l
+	if m.Uid != 0 {
+		n += 1 + sovExp(uint64(m.Uid))
+	}
+	if m.Uexp != 0 {
+		n += 1 + sovExp(uint64(m.Uexp))
+	}
+	if m.Rexp != 0 {
+		n += 1 + sovExp(uint64(m.Rexp))
+	}
+	return n
+}
+
+func (m *Level) Size() (n int) {
+	var l int
+	_ = l
+	if m.Uid != 0 {
+		n += 1 + sovExp(uint64(m.Uid))
+	}
+	if m.Uexp != 0 {
+		n += 1 + sovExp(uint64(m.Uexp))
+	}
+	if m.Rexp != 0 {
+		n += 1 + sovExp(uint64(m.Rexp))
+	}
+	if m.Ulevel != 0 {
+		n += 1 + sovExp(uint64(m.Ulevel))
+	}
+	if m.Rlevel != 0 {
+		n += 1 + sovExp(uint64(m.Rlevel))
+	}
+	if m.Color != 0 {
+		n += 1 + sovExp(uint64(m.Color))
+	}
+	if m.Unext != 0 {
+		n += 1 + sovExp(uint64(m.Unext))
+	}
+	if m.Rnext != 0 {
+		n += 1 + sovExp(uint64(m.Rnext))
+	}
+	return n
+}
+
+func sovExp(x uint64) (n int) {
+	for {
+		n++
+		x >>= 7
+		if x == 0 {
+			break
+		}
+	}
+	return n
+}
+func sozExp(x uint64) (n int) {
+	return sovExp(uint64((x << 1) ^ uint64((int64(x) >> 63))))
+}
+func (m *Exp) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowExp
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: Exp: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: Exp: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Uid", wireType)
+			}
+			m.Uid = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowExp
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Uid |= (int64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 2:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Uexp", wireType)
+			}
+			m.Uexp = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowExp
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Uexp |= (int64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 3:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Rexp", wireType)
+			}
+			m.Rexp = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowExp
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Rexp |= (int64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		default:
+			iNdEx = preIndex
+			skippy, err := skipExp(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthExp
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *Level) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowExp
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: Level: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: Level: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Uid", wireType)
+			}
+			m.Uid = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowExp
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Uid |= (int64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 2:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Uexp", wireType)
+			}
+			m.Uexp = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowExp
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Uexp |= (int64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 3:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Rexp", wireType)
+			}
+			m.Rexp = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowExp
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Rexp |= (int64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 4:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Ulevel", wireType)
+			}
+			m.Ulevel = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowExp
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Ulevel |= (int32(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 5:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Rlevel", wireType)
+			}
+			m.Rlevel = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowExp
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Rlevel |= (int32(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 6:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Color", wireType)
+			}
+			m.Color = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowExp
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Color |= (int32(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 7:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Unext", wireType)
+			}
+			m.Unext = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowExp
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Unext |= (int64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 8:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Rnext", wireType)
+			}
+			m.Rnext = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowExp
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Rnext |= (int64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		default:
+			iNdEx = preIndex
+			skippy, err := skipExp(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthExp
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func skipExp(dAtA []byte) (n int, err error) {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return 0, ErrIntOverflowExp
+			}
+			if iNdEx >= l {
+				return 0, io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		wireType := int(wire & 0x7)
+		switch wireType {
+		case 0:
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return 0, ErrIntOverflowExp
+				}
+				if iNdEx >= l {
+					return 0, io.ErrUnexpectedEOF
+				}
+				iNdEx++
+				if dAtA[iNdEx-1] < 0x80 {
+					break
+				}
+			}
+			return iNdEx, nil
+		case 1:
+			iNdEx += 8
+			return iNdEx, nil
+		case 2:
+			var length int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return 0, ErrIntOverflowExp
+				}
+				if iNdEx >= l {
+					return 0, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				length |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			iNdEx += length
+			if length < 0 {
+				return 0, ErrInvalidLengthExp
+			}
+			return iNdEx, nil
+		case 3:
+			for {
+				var innerWire uint64
+				var start int = iNdEx
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return 0, ErrIntOverflowExp
+					}
+					if iNdEx >= l {
+						return 0, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					innerWire |= (uint64(b) & 0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				innerWireType := int(innerWire & 0x7)
+				if innerWireType == 4 {
+					break
+				}
+				next, err := skipExp(dAtA[start:])
+				if err != nil {
+					return 0, err
+				}
+				iNdEx = start + next
+			}
+			return iNdEx, nil
+		case 4:
+			return iNdEx, nil
+		case 5:
+			iNdEx += 4
+			return iNdEx, nil
+		default:
+			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
+		}
+	}
+	panic("unreachable")
+}
+
+var (
+	ErrInvalidLengthExp = fmt.Errorf("proto: negative length found during unmarshaling")
+	ErrIntOverflowExp   = fmt.Errorf("proto: integer overflow")
+)
+
+func init() { proto.RegisterFile("exp.proto", fileDescriptorExp) }
+
+var fileDescriptorExp = []byte{
+	// 266 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x91, 0x31, 0x4e, 0xf3, 0x30,
+	0x14, 0x80, 0x7f, 0x37, 0x71, 0xda, 0x7a, 0xfa, 0xe5, 0xc9, 0x20, 0x14, 0x57, 0x99, 0xba, 0xd0,
+	0x0e, 0xdc, 0x20, 0x88, 0x8d, 0xc9, 0x52, 0x36, 0xa6, 0x34, 0x26, 0x44, 0x4a, 0xb1, 0x65, 0xc5,
+	0xc8, 0x57, 0xe0, 0x06, 0x1c, 0x89, 0x91, 0x13, 0x44, 0x28, 0x6c, 0x39, 0x05, 0x7a, 0xcf, 0x95,
+	0x72, 0x02, 0x36, 0xbf, 0xef, 0xfb, 0xac, 0x67, 0xc9, 0x6c, 0xab, 0x83, 0x3d, 0x58, 0x67, 0x06,
+	0xc3, 0xe9, 0xd9, 0x34, 0xba, 0xbf, 0xbe, 0x6d, 0xbb, 0xe1, 0xc5, 0xd7, 0x87, 0x93, 0x39, 0x1f,
+	0x5b, 0xd3, 0x9a, 0x23, 0xda, 0xda, 0x3f, 0xe3, 0x84, 0x03, 0x9e, 0xe2, 0xad, 0xe2, 0x89, 0x25,
+	0x0f, 0xc1, 0xf2, 0x2b, 0x96, 0x54, 0x5d, 0x23, 0xc8, 0x8e, 0xec, 0x93, 0x72, 0x3d, 0x8f, 0x32,
+	0xf1, 0x5d, 0xa3, 0x80, 0xf1, 0x1b, 0x96, 0x56, 0x3a, 0x58, 0xb1, 0x42, 0xb7, 0x99, 0x47, 0x99,
+	0x7a, 0x1d, 0xac, 0x42, 0x0a, 0x56, 0x81, 0x4d, 0x16, 0xeb, 0xd0, 0x02, 0x2d, 0xde, 0x57, 0x8c,
+	0x3e, 0xea, 0x37, 0xdd, 0xff, 0xd1, 0x02, 0x5e, 0xb0, 0xac, 0xea, 0x61, 0x81, 0x48, 0x77, 0x64,
+	0x4f, 0x4b, 0x36, 0x8f, 0x32, 0xf3, 0x48, 0xd4, 0xc5, 0x40, 0xa3, 0x62, 0x43, 0x97, 0xc6, 0x5d,
+	0x9a, 0x68, 0xb8, 0x64, 0xf4, 0xde, 0xf4, 0xc6, 0x89, 0x0c, 0x93, 0xed, 0x3c, 0x4a, 0x7a, 0x02,
+	0xa0, 0x22, 0x87, 0xa0, 0x7a, 0xd5, 0x61, 0x10, 0x6b, 0x7c, 0x07, 0x06, 0x1e, 0x80, 0x8a, 0x1c,
+	0x02, 0x85, 0xc1, 0x66, 0x09, 0x5c, 0x0c, 0x90, 0x97, 0xff, 0x3f, 0xa7, 0x9c, 0x7c, 0x4d, 0x39,
+	0xf9, 0x9e, 0x72, 0xf2, 0xf1, 0x93, 0xff, 0xab, 0x33, 0xfc, 0x82, 0xbb, 0xdf, 0x00, 0x00, 0x00,
+	0xff, 0xff, 0x9c, 0x9c, 0xce, 0x04, 0xc5, 0x01, 0x00, 0x00,
+}

app/job/live-userexp/model/exp.proto

@@ -0,0 +1,20 @@
+syntax = "proto3";
+package model;
+import "github.com/gogo/protobuf/gogoproto/gogo.proto";
+
+message Exp {
+    int64 Uid = 1 [(gogoproto.jsontag) = "uid"];
+    int64 Uexp = 2 [(gogoproto.jsontag) = "uexp"];
+    int64 Rexp = 3 [(gogoproto.jsontag) = "rexp"];
+}
+
+message Level {
+    int64 Uid = 1 [(gogoproto.jsontag) = "uid"];
+    int64 Uexp = 2 [(gogoproto.jsontag) = "uexp"];
+    int64 Rexp = 3 [(gogoproto.jsontag) = "rexp"];
+    int32 Ulevel = 4 [(gogoproto.jsontag) = "ulevel"];
+    int32 Rlevel = 5 [(gogoproto.jsontag) = "rlevel"];
+    int32 Color = 6 [(gogoproto.jsontag) = "color"];
+    int64 Unext = 7 [(gogoproto.jsontag) = "unext"];
+    int64 Rnext = 8 [(gogoproto.jsontag) = "rnext"];
+}

app/job/live-userexp/model/model.go

@@ -0,0 +1,11 @@
+package model
+
+import "encoding/json"
+
+// Message canal standary message
+type Message struct {
+	Action string          `json:"action"`
+	Table  string          `json:"table"`
+	New    json.RawMessage `json:"new"`
+	Old    json.RawMessage `json:"old"`
+}

app/job/live-userexp/service/BUILD

@@ -0,0 +1,50 @@
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+    "go_test",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "exp.go",
+        "service.go",
+    ],
+    importpath = "go-common/app/job/live-userexp/service",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/job/live-userexp/conf:go_default_library",
+        "//app/job/live-userexp/dao:go_default_library",
+        "//app/job/live-userexp/model:go_default_library",
+        "//library/log:go_default_library",
+        "//library/queue/databus:go_default_library",
+    ],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["exp_test.go"],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/job/live-userexp/conf:go_default_library",
+        "//app/job/live-userexp/model:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey: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/live-userexp/service/exp.go

@@ -0,0 +1,19 @@
+package service
+
+import (
+	"context"
+	"encoding/json"
+
+	"go-common/app/job/live-userexp/model"
+	"go-common/library/log"
+)
+
+func (s *Service) levelCacheUpdate(nwMsg []byte, oldMsg []byte) {
+	exp := &model.Exp{}
+	if err := json.Unmarshal(nwMsg, exp); err != nil {
+		log.Error("json.Unmarshal(%s) error(%v)", string(nwMsg), err)
+		return
+	}
+	level := model.FormatLevel(exp)
+	s.dao.SetLevelCache(context.TODO(), level)
+}

app/job/live-userexp/service/exp_test.go

@@ -0,0 +1,39 @@
+package service
+
+import (
+	"fmt"
+	"sync"
+	"testing"
+	"time"
+
+	"encoding/json"
+	"go-common/app/job/live-userexp/conf"
+	"go-common/app/job/live-userexp/model"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+var (
+	once sync.Once
+	s    *Service
+)
+
+func startService() {
+	if err := conf.Init(); err != nil {
+		panic(fmt.Sprintf("conf.Init() error(%v)", err))
+	}
+	s = New(conf.Conf)
+}
+
+func TestLevelCacheUpdate(t *testing.T) {
+	Convey("Cache update", t, func() {
+		once.Do(startService)
+		time.Sleep(time.Second)
+
+		m := &model.Message{}
+		exp := &model.Exp{}
+		m.New, _ = json.Marshal(exp)
+		m.Old, _ = json.Marshal(exp)
+		s.levelCacheUpdate(m.New, m.Old)
+	})
+}

app/job/live-userexp/service/service.go

@@ -0,0 +1,104 @@
+package service
+
+import (
+	"context"
+	"encoding/json"
+	"strings"
+	"sync"
+	"time"
+
+	"go-common/app/job/live-userexp/conf"
+	"go-common/app/job/live-userexp/dao"
+	"go-common/app/job/live-userexp/model"
+	"go-common/library/log"
+	"go-common/library/queue/databus"
+)
+
+// Service http service
+type Service struct {
+	c       *conf.Config
+	keys    map[string]string
+	dao     *dao.Dao
+	missch  chan func()
+	expSub  *databus.Databus
+	waiter  *sync.WaitGroup
+	expUpMo int64
+}
+
+// New for new service obj
+func New(c *conf.Config) *Service {
+	s := &Service{
+		c:      c,
+		keys:   map[string]string{},
+		dao:    dao.New(c),
+		missch: make(chan func(), 1024),
+		expSub: databus.New(c.ExpSub),
+		waiter: new(sync.WaitGroup),
+	}
+	s.waiter.Add(1)
+	go s.expCanalConsumeproc()
+	go s.checkExpCanalConsumeproc()
+	return s
+}
+
+// Ping check server ok
+func (s *Service) Ping(c context.Context) (err error) {
+	return s.dao.Ping(c)
+}
+
+// Close dao
+func (s *Service) Close() {
+	defer s.waiter.Wait()
+	s.expSub.Close()
+	s.dao.Close()
+}
+
+// expCanalConsumeproc consumer archive
+func (s *Service) expCanalConsumeproc() {
+	var (
+		msgs = s.expSub.Messages()
+		err  error
+	)
+	defer s.waiter.Done()
+	for {
+		msg, ok := <-msgs
+		if !ok {
+			log.Info("expCanal databus Consumer exit")
+			return
+		}
+		s.expUpMo++
+		msg.Commit()
+		m := &model.Message{}
+		if err = json.Unmarshal(msg.Value, m); err != nil {
+			log.Error("json.Unmarshal(%s) error(%v)", msg.Value, err)
+			continue
+		}
+		if !strings.HasPrefix(m.Table, "user_exp_") || m.Action != "update" {
+			continue
+		}
+		s.levelCacheUpdate(m.New, m.Old)
+	}
+}
+
+// checkConsumeproc check consumer stat
+func (s *Service) checkExpCanalConsumeproc() {
+	if s.c.Env != "pro" {
+		return
+	}
+	var expMo int64
+	for {
+		time.Sleep(1 * time.Minute)
+		if s.expUpMo-expMo == 0 {
+			msg := "live-userexp-job expCanal did not consume within a minute"
+			//s.dao.SendSMS(msg)
+			log.Warn(msg)
+		}
+
+		expMo = s.expUpMo
+	}
+}
+
+// Wait goroutinue to close
+func (s *Service) Wait() {
+	s.waiter.Wait()
+}