Create & Init Project...

app/job/main/web-goblin/service/esports/BUILD

@@ -0,0 +1,39 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["service.go"],
+    importpath = "go-common/app/job/main/web-goblin/service/esports",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/job/main/web-goblin/conf:go_default_library",
+        "//app/job/main/web-goblin/dao/esports:go_default_library",
+        "//app/job/main/web-goblin/model/esports:go_default_library",
+        "//app/service/main/archive/api:go_default_library",
+        "//app/service/main/favorite/api/gorpc:go_default_library",
+        "//app/service/main/favorite/model:go_default_library",
+        "//library/ecode:go_default_library",
+        "//library/log: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/web-goblin/service/esports/service.go

@@ -0,0 +1,271 @@
+package esports
+
+import (
+	"context"
+	"fmt"
+	"math"
+	"time"
+
+	"go-common/app/job/main/web-goblin/conf"
+	"go-common/app/job/main/web-goblin/dao/esports"
+	mdlesp "go-common/app/job/main/web-goblin/model/esports"
+	arcclient "go-common/app/service/main/archive/api"
+	arcmdl "go-common/app/service/main/archive/api"
+	favrpc "go-common/app/service/main/favorite/api/gorpc"
+	"go-common/app/service/main/favorite/model"
+	mdlfav "go-common/app/service/main/favorite/model"
+	"go-common/library/ecode"
+	"go-common/library/log"
+
+	"github.com/pkg/errors"
+)
+
+const (
+	_favUsers    = 1000
+	_favTryTimes = 3
+	_defContest  = 0
+	_linkinfo    = "点击前往直播间"
+	_pushinfo    = "进入直播>>"
+	_msgSize     = 1000
+	_tpMessage   = 0
+	_tpPush      = 1
+	_arcMaxLimit = 50
+)
+
+// Service struct
+type Service struct {
+	c   *conf.Config
+	dao *esports.Dao
+	// rpc
+	fav       *favrpc.Service
+	arcClient arcclient.ArchiveClient
+}
+
+// New init
+func New(c *conf.Config) (s *Service) {
+	s = &Service{
+		c:   c,
+		dao: esports.New(c),
+		fav: favrpc.New2(c.FavoriteRPC),
+	}
+	var err error
+	if s.arcClient, err = arcclient.NewClient(c.ArcClient); err != nil {
+		panic(err)
+	}
+	go s.contests()
+	go s.contestsPush()
+	go s.arcScore()
+	return s
+}
+
+func (s *Service) contests() {
+	var (
+		err      error
+		contests []*mdlesp.Contest
+	)
+	for {
+		stime := time.Now().Add(time.Duration(s.c.Rule.Before))
+		etime := stime.Add(time.Duration(s.c.Rule.SleepInterval))
+		if contests, err = s.dao.Contests(context.Background(), stime.Unix(), etime.Unix()); err != nil {
+			time.Sleep(time.Second)
+			log.Error("contests s.dao.Contests stime(%d) error(%v)", stime.Unix(), err)
+			continue
+		}
+		for _, contest := range contests {
+			tmpContest := contest
+			go s.sendContests(tmpContest)
+		}
+		time.Sleep(time.Duration(s.c.Rule.SleepInterval))
+	}
+}
+
+func (s *Service) contestsPush() {
+	var (
+		err      error
+		contests []*mdlesp.Contest
+	)
+	for {
+		stime := time.Now()
+		etime := stime.Add(time.Second)
+		if contests, err = s.dao.Contests(context.Background(), stime.Unix(), etime.Unix()); err != nil {
+			time.Sleep(time.Millisecond * 100)
+			log.Error("contestsPush s.dao.Contests stime(%d) error(%v)", stime.Unix(), err)
+			continue
+		}
+		for _, contest := range contests {
+			tmpContest := contest
+			go s.pubContests(tmpContest)
+		}
+		time.Sleep(time.Second)
+	}
+}
+
+// Ping Service
+func (s *Service) Ping(c context.Context) (err error) {
+	return s.dao.Ping(c)
+}
+
+// Close Service
+func (s *Service) Close() {
+	s.dao.Close()
+}
+
+func (s *Service) sendContests(contest *mdlesp.Contest) (err error) {
+	var (
+		mids []int64
+		msg  string
+	)
+	link := fmt.Sprintf("#{%s}{\"https://live.bilibili.com/%d\"}", _linkinfo, contest.LiveRoom)
+	if mids, msg, err = s.midsParams(contest, link, _tpMessage); err != nil {
+		log.Error("sendContests s.midsParams(%+v) mids_total(%d) error(%v)", contest, len(mids), err)
+		return
+	}
+	s.dao.Batch(mids, msg, contest, _msgSize, s.dao.SendMessage)
+	return
+}
+
+func (s *Service) pubContests(contest *mdlesp.Contest) (err error) {
+	var (
+		mids []int64
+		msg  string
+	)
+	if mids, msg, err = s.midsParams(contest, _pushinfo, _tpPush); err != nil {
+		log.Error("pubContests s.midsParams(%+v) mids_total(%d) error(%v)", contest, len(mids), err)
+		return
+	}
+	s.dao.Batch(mids, msg, contest, s.c.Push.PartSize, s.dao.NoticeUser)
+	return
+}
+
+func (s *Service) midsParams(contest *mdlesp.Contest, link string, tp int) (mids []int64, msg string, err error) {
+	var (
+		userList       *mdlfav.UserList
+		teams          []*mdlesp.Team
+		homeID, awayID int64
+		tMap           map[int64]string
+		pageCount      int
+	)
+	if userList, err = s.favUsers(contest.ID, 1); err != nil || userList == nil || len(userList.List) == 0 {
+		log.Error("s.favUsers  contestID(%v) first error(%+v)", contest.ID, err)
+		return
+	}
+	ms := make(map[int64]struct{}, userList.Page.Total)
+	for _, user := range userList.List {
+		if _, ok := ms[user.Mid]; ok {
+			continue
+		}
+		ms[user.Mid] = struct{}{}
+		mids = append(mids, user.Mid)
+	}
+	if userList.Page.Size == 0 {
+		pageCount = 0
+	} else {
+		pageCount = int(math.Ceil(float64(userList.Page.Total) / float64(userList.Page.Size)))
+	}
+	for i := 2; i <= pageCount; i++ {
+		if userList, err = s.favUsers(contest.ID, i); err != nil || userList == nil || len(userList.List) == 0 {
+			log.Error("s.favUsers  contestID(%v) pn(%d) error(%+v)", contest.ID, i, err)
+			err = nil
+			continue
+		}
+		for _, user := range userList.List {
+			if _, ok := ms[user.Mid]; ok {
+				continue
+			}
+			ms[user.Mid] = struct{}{}
+			mids = append(mids, user.Mid)
+		}
+	}
+	if len(mids) == 0 {
+		err = ecode.RequestErr
+		return
+	}
+	tm := time.Unix(contest.Stime, 0)
+	stime := tm.Format("2006-01-02 15:04:05")
+	if contest.Special == _defContest {
+		homeID = contest.HomeID
+		awayID = contest.AwayID
+		if teams, err = s.dao.Teams(context.Background(), homeID, awayID); err != nil || len(teams) == 0 {
+			log.Error("midsParams  s.dao.Teams homeID(%d) awayID(%d) error(%v)", homeID, awayID, err)
+			return
+		}
+		tMap = make(map[int64]string, 2)
+		for _, temp := range teams {
+			tMap[temp.ID] = temp.Title
+		}
+		if tp == _tpMessage {
+			msg = fmt.Sprintf(s.c.Rule.AlertBodyDefault, contest.SeasonTitle, stime, tMap[contest.HomeID], tMap[contest.AwayID], link)
+		} else if tp == _tpPush {
+			msg = fmt.Sprintf(s.c.Push.BodyDefault, contest.SeasonTitle, tMap[contest.HomeID], tMap[contest.AwayID], link)
+		}
+	} else {
+		if tp == _tpMessage {
+			msg = fmt.Sprintf(s.c.Rule.AlertBodySpecial, contest.SeasonTitle, stime, contest.SpecialName, link)
+		} else if tp == _tpPush {
+			msg = fmt.Sprintf(s.c.Push.BodySpecial, contest.SeasonTitle, contest.SpecialName, link)
+		}
+	}
+	count := len(mids)
+	log.Info("midsParams get contest cid(%d) users number(%d)", contest.ID, count)
+	return
+}
+
+func (s *Service) favUsers(cid int64, pn int) (res *mdlfav.UserList, err error) {
+	for i := 0; i < _favTryTimes; i++ {
+		if res, err = s.fav.Users(context.Background(), &model.ArgUsers{Type: model.TypeEsports, Oid: cid, Pn: pn, Ps: _favUsers}); err == nil {
+			break
+		}
+		time.Sleep(time.Millisecond * 100)
+	}
+	if err != nil {
+		err = errors.Wrapf(err, "favUsers s.fav.Users cid(%d) pn(%d)", cid, pn)
+	}
+	return
+}
+
+func (s *Service) arcScore() {
+	var (
+		id int64
+		c  = context.Background()
+	)
+	for {
+		av, err := s.dao.Arcs(c, id, _arcMaxLimit)
+		if err != nil {
+			log.Error("ArcScore  s.dao.Arcs ID(%d) Limit(%d) error(%v)", id, _arcMaxLimit, err)
+			id = id + int64(_arcMaxLimit)
+			time.Sleep(time.Second)
+			continue
+		}
+		if len(av) == 0 {
+			id = 0
+			time.Sleep(time.Duration(s.c.Rule.ScoreSleep))
+			continue
+		}
+		go s.upArcScore(c, av)
+		id = av[len(av)-1].ID
+		time.Sleep(time.Second)
+	}
+}
+
+func (s *Service) upArcScore(c context.Context, partArcs []*mdlesp.Arc) (err error) {
+	var (
+		partAids  []int64
+		arcsReply *arcmdl.ArcsReply
+	)
+	for _, arc := range partArcs {
+		partAids = append(partAids, arc.Aid)
+	}
+	if len(partAids) == 0 {
+		return
+	}
+	if arcsReply, err = s.arcClient.Arcs(c, &arcmdl.ArcsRequest{Aids: partAids}); err != nil || arcsReply == nil {
+		log.Error("upArcScore  s.arcClient.Arcs(%v) error(%v)", partAids, err)
+		return
+	}
+	if len(arcsReply.Arcs) > 0 {
+		if err = s.dao.UpArcScore(c, partArcs, arcsReply.Arcs); err != nil {
+			log.Error("upArcScore  s.dao.UpArcScore arcs(%+v) error(%v)", arcsReply, err)
+		}
+	}
+	return
+}

app/job/main/web-goblin/service/web/BUILD

@@ -0,0 +1,56 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+    "go_test",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "service.go",
+        "ugc.go",
+    ],
+    importpath = "go-common/app/job/main/web-goblin/service/web",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/job/main/web-goblin/conf:go_default_library",
+        "//app/job/main/web-goblin/dao/web:go_default_library",
+        "//app/job/main/web-goblin/model/web:go_default_library",
+        "//app/service/main/dynamic/model:go_default_library",
+        "//app/service/main/dynamic/rpc/client: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"],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = [
+        "service_test.go",
+        "ugc_test.go",
+    ],
+    embed = [":go_default_library"],
+    tags = ["automanaged"],
+    deps = [
+        "//app/job/main/web-goblin/conf:go_default_library",
+        "//app/job/main/web-goblin/model/web:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)

app/job/main/web-goblin/service/web/service.go

@@ -0,0 +1,104 @@
+package web
+
+import (
+	"context"
+	"encoding/json"
+	"sync"
+	"time"
+
+	"go-common/app/job/main/web-goblin/conf"
+	mdlweb "go-common/app/job/main/web-goblin/dao/web"
+	"go-common/app/job/main/web-goblin/model/web"
+	dymdl "go-common/app/service/main/dynamic/model"
+	dyrpc "go-common/app/service/main/dynamic/rpc/client"
+	"go-common/library/log"
+	"go-common/library/queue/databus"
+)
+
+// Service struct .
+type Service struct {
+	c                *conf.Config
+	dao              *mdlweb.Dao
+	dy               *dyrpc.Service
+	waiter           *sync.WaitGroup
+	archiveNotifySub *databus.Databus
+}
+
+// New init .
+func New(c *conf.Config) (s *Service) {
+	s = &Service{
+		c:                c,
+		dao:              mdlweb.New(c),
+		dy:               dyrpc.New(c.DynamicRPC),
+		waiter:           new(sync.WaitGroup),
+		archiveNotifySub: databus.New(c.ArchiveNotifySub),
+	}
+	go s.broadcastDy()
+	s.waiter.Add(1)
+	go s.allSearch()
+	return s
+}
+
+// Ping Service .
+func (s *Service) Ping(c context.Context) (err error) {
+	return s.dao.Ping(c)
+}
+
+// Close Service .
+func (s *Service) Close() {
+	s.dao.Close()
+}
+
+func (s *Service) broadcastDy() {
+	var (
+		dynamics map[string]int
+		err      error
+		b        []byte
+	)
+	for {
+		if dynamics, err = s.dy.RegionTotal(context.Background(), &dymdl.ArgRegionTotal{RealIP: ""}); err != nil {
+			mdlweb.PromError("RegionTotal接口错误", "s.dy.RegionTotal error(%v)", err)
+			time.Sleep(time.Second)
+			continue
+		}
+		if b, err = json.Marshal(dynamics); err != nil {
+			log.Error("broadcastDy json.Marshal error(%v)", err)
+			return
+		}
+		if err = s.dao.PushAll(context.Background(), string(b), ""); err != nil {
+			log.Error("s.dao.PushAll(%+v) error(%v)", dynamics, err)
+			time.Sleep(time.Second)
+			continue
+		}
+		time.Sleep(time.Second * 5)
+	}
+}
+
+func (s *Service) allSearch() {
+	var (
+		err error
+		ctx = context.Background()
+	)
+
+	defer s.waiter.Done()
+	for {
+		msg, ok := <-s.archiveNotifySub.Messages()
+		if !ok {
+			log.Error("web-goblin-job databus Consumer exit")
+			return
+		}
+		res := &web.ArcMsg{}
+		if err = json.Unmarshal(msg.Value, res); err != nil {
+			msg.Commit()
+			log.Error("json.Unmarshal(%s) error(%v)", msg.Value, err)
+			continue
+		}
+		if res.Table != _archive {
+			continue
+		}
+		s.UgcIncrement(ctx, res)
+		msg.Commit()
+		log.Info("consume allSearch ugc key:%s partition:%d offset:%d)", msg.Key, msg.Partition, msg.Offset)
+		time.Sleep(10 * time.Millisecond)
+	}
+}

app/job/main/web-goblin/service/web/service_test.go

@@ -0,0 +1,27 @@
+package web
+
+import (
+	"flag"
+	"path/filepath"
+	"time"
+
+	"go-common/app/job/main/web-goblin/conf"
+)
+
+var (
+	srv *Service
+)
+
+func init() {
+	dir, _ := filepath.Abs("../../cmd/web-goblin-job-test.toml")
+	flag.Set("conf", dir)
+	conf.Init()
+	srv = New(conf.Conf)
+	time.Sleep(time.Second)
+}
+
+func WithService(f func(s *Service)) func() {
+	return func() {
+		f(srv)
+	}
+}

app/job/main/web-goblin/service/web/ugc.go

@@ -0,0 +1,45 @@
+package web
+
+import (
+	"context"
+	"time"
+
+	"go-common/app/job/main/web-goblin/model/web"
+	"go-common/library/log"
+)
+
+const (
+	_opadd   = "add"
+	_opdel   = "del"
+	_insert  = "insert"
+	_update  = "update"
+	_archive = "archive"
+)
+
+// UgcIncrement ugc increment .
+func (s *Service) UgcIncrement(ctx context.Context, arg *web.ArcMsg) (err error) {
+	m := make(map[string]interface{})
+	if arg.New.CTime != "" {
+		m["ctime"] = arg.New.CTime
+	}
+	m["mtime"] = time.Now().Format("2006-01-02 15:04:05")
+	if arg.New.PubTime != "" {
+		m["ptime"] = arg.New.PubTime
+	}
+	m["mid"] = arg.New.Mid
+	m["aid"] = arg.New.Aid
+	if arg.Action == _insert {
+		m["action"] = _opadd
+	}
+	if arg.Action == _update {
+		if arg.New.State != arg.Old.State && arg.New.State < 0 {
+			m["action"] = _opdel
+		} else {
+			m["action"] = _update
+		}
+	}
+	if err = s.dao.UgcSearch(ctx, m); err != nil {
+		log.Error("s.dao.UgcIncre error", err)
+	}
+	return
+}

app/job/main/web-goblin/service/web/ugc_test.go

@@ -0,0 +1,26 @@
+package web
+
+import (
+	"context"
+	"testing"
+
+	"go-common/app/job/main/web-goblin/model/web"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+func TestService_UgcIncrement(t *testing.T) {
+	Convey("test UgcIncrement", t, WithService(func(s *Service) {
+		var (
+			err error
+			ctx = context.Background()
+			v   = &web.ArcMsg{
+				Action: "add",
+				Table:  "archive",
+				New:    nil,
+			}
+		)
+		err = s.UgcIncrement(ctx, v)
+		So(err, ShouldBeNil)
+	}))
+}