Create & Init Project...

app/job/main/block/service/BUILD

@@ -0,0 +1,58 @@
+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/block/conf:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "audit_log.go",
+        "blackhouse.go",
+        "limit.go",
+        "msg.go",
+        "notify.go",
+        "service.go",
+    ],
+    importpath = "go-common/app/job/main/block/service",
+    tags = ["automanaged"],
+    deps = [
+        "//app/job/main/block/conf:go_default_library",
+        "//app/job/main/block/dao:go_default_library",
+        "//app/job/main/block/model:go_default_library",
+        "//library/cache:go_default_library",
+        "//library/database/sql:go_default_library",
+        "//library/log:go_default_library",
+        "//library/queue/databus:go_default_library",
+        "//library/queue/databus/report: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/block/service/audit_log.go

@@ -0,0 +1,48 @@
+package service
+
+import (
+	"context"
+	"strconv"
+	"time"
+
+	"go-common/app/job/main/block/model"
+	"go-common/library/log"
+	manager "go-common/library/queue/databus/report"
+)
+
+// AddAuditLog .
+func (s *Service) AddAuditLog(c context.Context, tp model.BlockAction, uid int64, uname string, oids []int64, duration time.Duration, source model.BlockSource, area model.BlockArea, reason, comment string, notify bool, stime time.Time) error {
+	var (
+		err       error
+		dur       = int64(duration / time.Second)
+		notifyStr = strconv.FormatBool(notify)
+	)
+	for _, oid := range oids {
+		managerInfo := &manager.ManagerInfo{
+			UID:      uid,
+			Uname:    uname,
+			Business: model.BlockLogBizID,
+			Type:     int(tp),
+			Action:   tp.String(),
+			Oid:      oid,
+			Ctime:    time.Now(),
+			Index:    []interface{}{dur, uint8(source), uint8(area), reason, comment, notifyStr},
+			Content: map[string]interface{}{
+				"duration":    dur,
+				"source":      source,
+				"area":        area,
+				"reason":      reason,
+				"comment":     comment,
+				"notify":      notifyStr,
+				"action_time": stime.Unix(),
+				"remove_time": stime.Add(time.Second * time.Duration(dur)).Unix(),
+			},
+		}
+		if err = manager.Manager(managerInfo); err != nil {
+			log.Error("manager.Manager(%+v) error(%+v)", managerInfo, err)
+			continue
+		}
+		log.Info("s.managerSendLog(%+v)", managerInfo)
+	}
+	return err
+}

app/job/main/block/service/blackhouse.go

@@ -0,0 +1,200 @@
+package service
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"time"
+
+	"go-common/app/job/main/block/conf"
+	"go-common/app/job/main/block/model"
+	xsql "go-common/library/database/sql"
+	"go-common/library/log"
+	"go-common/library/queue/databus"
+
+	"github.com/pkg/errors"
+)
+
+func (s *Service) creditExpireHandler(c context.Context) {
+	if conf.Conf.Property.CreditExpireCheckLimit <= 0 {
+		log.Error("conf.Conf.Property.creditExpireCheckLimit [%d] <= 0", conf.Conf.Property.CreditExpireCheckLimit)
+		return
+	}
+	var (
+		mids    = make([]int64, conf.Conf.Property.CreditExpireCheckLimit)
+		startID int64
+		err     error
+	)
+	for len(mids) >= conf.Conf.Property.CreditExpireCheckLimit {
+		log.Info("black house expire handle startID (%d)", startID)
+		if startID, mids, err = s.dao.UserStatusList(c, model.BlockStatusCredit, startID, conf.Conf.Property.CreditExpireCheckLimit); err != nil {
+			log.Error("%+v", err)
+			return
+		}
+		for _, mid := range mids {
+			log.Info("Start handle black house mid (%d)", mid)
+			var ok bool
+			if ok, err = s.creditExpireCheck(c, mid); err != nil {
+				log.Error("%+v", err)
+				continue
+			}
+			if ok {
+				log.Info("Start remove black house mid (%d)", mid)
+				if err = s.creditExpireRemove(c, mid); err != nil {
+					log.Error("%+v", err)
+				}
+			}
+		}
+	}
+}
+
+func (s *Service) creditExpireCheck(c context.Context, mid int64) (ok bool, err error) {
+	var (
+		his *model.DBHistory
+		ex  *model.DBExtra
+	)
+	if his, err = s.dao.UserLastHistory(c, mid); err != nil {
+		return
+	}
+	if his == nil {
+		return
+	}
+	log.Info("Credit check his (%+v)", his)
+	if his.Action != model.BlockActionLimit || his.Source != model.BlockSourceCredit {
+		return
+	}
+	if ex, err = s.dao.UserExtra(c, mid); err != nil {
+		return
+	}
+	if ex == nil {
+		return
+	}
+	log.Info("Credit check extra (%+v)", his)
+	if ex.ActionTime.Before(his.StartTime) {
+		return
+	}
+	if his.StartTime.Add(time.Duration(his.Duration) * time.Second).After(time.Now()) {
+		return
+	}
+	ok = true
+	return
+}
+
+func (s *Service) creditExpireRemove(c context.Context, mid int64) (err error) {
+	var (
+		db = &model.DBHistory{
+			MID:       mid,
+			AdminID:   -1,
+			AdminName: "sys",
+			Source:    model.BlockSourceRemove,
+			Area:      model.BlockAreaNone,
+			Reason:    "小黑屋自动解封",
+			Comment:   "小黑屋自动解封",
+			Action:    model.BlockActionSelfRemove,
+			StartTime: time.Now(),
+			Duration:  0,
+			Notify:    false,
+		}
+		tx *xsql.Tx
+	)
+	if tx, err = s.dao.BeginTX(c); err != nil {
+		return
+	}
+	if err = s.dao.TxInsertHistory(c, tx, db); err != nil {
+		tx.Rollback()
+		return
+	}
+	if err = s.dao.TxUpsertUser(c, tx, mid, model.BlockStatusFalse); err != nil {
+		tx.Rollback()
+		return
+	}
+	if err = tx.Commit(); err != nil {
+		err = errors.WithStack(err)
+	}
+	s.mission(func() {
+		if err := s.notifyRemoveMSG(context.TODO(), []int64{mid}); err != nil {
+			log.Error("%+v", err)
+		}
+	})
+	s.cache.Save(func() {
+		if err := s.dao.DeleteUserCache(context.TODO(), mid); err != nil {
+			log.Error("%+v", err)
+		}
+		if databusErr := s.accountNotify(context.TODO(), mid); databusErr != nil {
+			log.Error("%+v", databusErr)
+		}
+	})
+	return
+}
+
+func (s *Service) notifyRemoveMSG(c context.Context, mids []int64) (err error) {
+	code, title, content := s.MSGRemoveInfo()
+	if err = s.dao.SendSysMsg(c, code, mids, title, content, ""); err != nil {
+		return
+	}
+	return
+}
+
+// databus
+func (s *Service) creditsubproc() {
+	defer func() {
+		if x := recover(); x != nil {
+			log.Error("%+v", errors.WithStack(fmt.Errorf("s.creditsubproc panic(%v)", x)))
+			go s.creditsubproc()
+			log.Info("s.creditsubproc recover")
+		}
+	}()
+	var (
+		msg      *databus.Message
+		eventMSG *model.CreditAnswerMSG
+		err      error
+		msgChan  = s.creditSub.Messages()
+		c        = context.TODO()
+	)
+	for msg = range msgChan {
+		if err = msg.Commit(); err != nil {
+			log.Error("msg.Commit error(%v)", err)
+		}
+		eventMSG = &model.CreditAnswerMSG{}
+		if err = json.Unmarshal([]byte(msg.Value), eventMSG); err != nil {
+			log.Error("%+v", errors.WithStack(err))
+			continue
+		}
+		if err = s.handleCreditAnswerMSG(c, eventMSG); err != nil {
+			log.Error("%+v", err)
+			continue
+		}
+		log.Info("s.handleCreditAnswerMSG(%v) msg", eventMSG)
+	}
+
+	log.Info("creditsubproc end")
+}
+
+func (s *Service) handleCreditAnswerMSG(c context.Context, msg *model.CreditAnswerMSG) (err error) {
+	if msg.MID <= 0 {
+		return
+	}
+	var (
+		extra = &model.DBExtra{
+			MID:              msg.MID,
+			CreditAnswerFlag: true,
+			ActionTime:       msg.MTime.Time(),
+		}
+		checkFlag bool
+	)
+	if err = s.dao.InsertExtra(c, extra); err != nil {
+		return
+	}
+	// 及时检查解封
+	log.Info("Start check black house mid (%d) from answer", extra.MID)
+	if checkFlag, err = s.creditExpireCheck(c, extra.MID); err != nil {
+		return
+	}
+	if checkFlag {
+		log.Info("Start remove black house mid (%d)", extra.MID)
+		if err = s.creditExpireRemove(c, extra.MID); err != nil {
+			return
+		}
+	}
+	return
+}

app/job/main/block/service/limit.go

@@ -0,0 +1,115 @@
+package service
+
+import (
+	"context"
+	"time"
+
+	"go-common/app/job/main/block/conf"
+	"go-common/app/job/main/block/model"
+	xsql "go-common/library/database/sql"
+	"go-common/library/log"
+
+	"github.com/pkg/errors"
+)
+
+func (s *Service) limitExpireHandler(c context.Context) {
+	if conf.Conf.Property.LimitExpireCheckLimit <= 0 {
+		log.Error("conf.Conf.Property.LimitExpireCheckLimit [%d] <= 0", conf.Conf.Property.LimitExpireCheckLimit)
+		return
+	}
+	var (
+		mids    = make([]int64, conf.Conf.Property.LimitExpireCheckLimit)
+		startID int64
+		err     error
+	)
+	for len(mids) >= conf.Conf.Property.LimitExpireCheckLimit {
+		log.Info("limit expire handle startID (%d)", startID)
+		if startID, mids, err = s.dao.UserStatusList(c, model.BlockStatusLimit, startID, conf.Conf.Property.LimitExpireCheckLimit); err != nil {
+			log.Error("%+v", err)
+			return
+		}
+		for _, mid := range mids {
+			var ok bool
+			if ok, err = s.limitExpireCheck(c, mid); err != nil {
+				log.Error("%+v", err)
+				continue
+			}
+			if ok {
+				s.limitExpireRemove(c, mid)
+			}
+			time.Sleep(time.Millisecond * 100)
+		}
+	}
+}
+
+func (s *Service) limitExpireCheck(c context.Context, mid int64) (ok bool, err error) {
+	var (
+		his *model.DBHistory
+	)
+	if his, err = s.dao.UserLastHistory(c, mid); err != nil {
+		return
+	}
+	if his == nil {
+		return
+	}
+	if his.Action != model.BlockActionLimit {
+		return
+	}
+	if his.StartTime.Add(time.Duration(his.Duration) * time.Second).After(time.Now()) {
+		return
+	}
+	ok = true
+	return
+}
+
+func (s *Service) limitExpireRemove(c context.Context, mid int64) (err error) {
+	var (
+		_reason, _comment = "系统自动解封", "系统自动解封"
+		stime             = time.Now()
+		db                = &model.DBHistory{
+			MID:       mid,
+			AdminID:   model.BlockJOBManagerID,
+			AdminName: model.BlockJOBManagerName,
+			Source:    model.BlockSourceRemove,
+			Area:      model.BlockAreaNone,
+			Reason:    _reason,
+			Comment:   _comment,
+			Action:    model.BlockActionSelfRemove,
+			StartTime: stime,
+			Duration:  0,
+			Notify:    false,
+		}
+		tx *xsql.Tx
+	)
+	if tx, err = s.dao.BeginTX(c); err != nil {
+		return
+	}
+	if err = s.dao.TxInsertHistory(c, tx, db); err != nil {
+		tx.Rollback()
+		return
+	}
+	if err = s.dao.TxUpsertUser(c, tx, mid, model.BlockStatusFalse); err != nil {
+		tx.Rollback()
+		return
+	}
+	if err = tx.Commit(); err != nil {
+		err = errors.WithStack(err)
+	}
+	s.mission(func() {
+		if err := s.notifyRemoveMSG(context.TODO(), []int64{mid}); err != nil {
+			log.Error("%+v", err)
+		}
+	})
+	s.mission(func() {
+		s.AddAuditLog(context.TODO(), model.BlockActionSelfRemove, model.BlockJOBManagerID, model.BlockJOBManagerName, []int64{mid}, 0, model.BlockSourceRemove, model.BlockAreaNone, _reason, _comment, false, stime)
+	})
+	s.cache.Save(func() {
+		if err := s.dao.DeleteUserCache(context.TODO(), mid); err != nil {
+			log.Error("%+v", err)
+		}
+		if databusErr := s.accountNotify(context.TODO(), mid); databusErr != nil {
+			log.Error("%+v", databusErr)
+		}
+	})
+	return
+}

app/job/main/block/service/msg.go

@@ -0,0 +1,13 @@
+package service
+
+import (
+	"go-common/app/job/main/block/conf"
+)
+
+// MSGRemoveInfo get msg info
+func (s *Service) MSGRemoveInfo() (code string, title, content string) {
+	code = conf.Conf.Property.MSG.BlockRemove.Code
+	title = conf.Conf.Property.MSG.BlockRemove.Title
+	content = conf.Conf.Property.MSG.BlockRemove.Content
+	return
+}

app/job/main/block/service/notify.go

@@ -0,0 +1,18 @@
+package service
+
+import (
+	"context"
+	"strconv"
+
+	"go-common/app/job/main/block/model"
+
+	"github.com/pkg/errors"
+)
+
+func (s *Service) accountNotify(c context.Context, mid int64) (err error) {
+	msg := &model.AccountNotify{UID: mid, Action: "blockUser"}
+	if err = s.accountNotifyPub.Send(c, strconv.FormatInt(msg.UID, 10), msg); err != nil {
+		err = errors.Errorf("mid(%d) s.accountNotify.Send(%+v) error(%+v)", msg.UID, msg, err)
+	}
+	return
+}

app/job/main/block/service/service.go

@@ -0,0 +1,114 @@
+package service
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"go-common/app/job/main/block/conf"
+	"go-common/app/job/main/block/dao"
+	"go-common/library/cache"
+	"go-common/library/log"
+	"go-common/library/queue/databus"
+
+	"github.com/pkg/errors"
+)
+
+// Service struct
+type Service struct {
+	dao    *dao.Dao
+	cache  *cache.Cache
+	missch chan func()
+
+	creditSub        *databus.Databus
+	accountNotifyPub *databus.Databus
+}
+
+// New init
+func New() (s *Service) {
+	s = &Service{
+		dao:              dao.New(),
+		cache:            cache.New(1, 10240),
+		missch:           make(chan func(), 10240),
+		creditSub:        databus.New(conf.Conf.Databus.Credit),
+		accountNotifyPub: databus.New(conf.Conf.AccountNotify),
+	}
+
+	// 自动解禁检查
+	if conf.Conf.Property.Flag.ExpireCheck {
+		go s.limitcheckproc()
+		go s.creditcheckproc()
+	}
+
+	// 小黑屋答题状态订阅
+	if conf.Conf.Property.Flag.CreditSub {
+		go s.creditsubproc()
+	}
+
+	go s.missproc()
+	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) limitcheckproc() {
+	defer func() {
+		if x := recover(); x != nil {
+			log.Error("service.limitcheckproc panic(%v)", x)
+			go s.limitcheckproc()
+			log.Info("service.limitcheckproc recover")
+		}
+	}()
+	for {
+		log.Info("limit check start")
+		s.limitExpireHandler(context.TODO())
+		log.Info("limit check end")
+		time.Sleep(time.Duration(conf.Conf.Property.LimitExpireCheckTick))
+	}
+}
+
+func (s *Service) creditcheckproc() {
+	defer func() {
+		if x := recover(); x != nil {
+			log.Error("%+v", errors.WithStack(fmt.Errorf("service.creditcheckproc panic(%v)", x)))
+			go s.creditcheckproc()
+			log.Info("service.creditcheckproc recover")
+		}
+	}()
+	for {
+		log.Info("black house check start")
+		s.creditExpireHandler(context.TODO())
+		log.Info("black house check end")
+		time.Sleep(time.Duration(conf.Conf.Property.CreditExpireCheckTick))
+	}
+}
+
+func (s *Service) missproc() {
+	defer func() {
+		if x := recover(); x != nil {
+			log.Error("service.missproc panic(%v)", x)
+			go s.missproc()
+			log.Info("service.missproc recover")
+		}
+	}()
+	for {
+		f := <-s.missch
+		f()
+	}
+}
+
+func (s *Service) mission(f func()) {
+	select {
+	case s.missch <- f:
+	default:
+		log.Error("s.missch full")
+	}
+}

app/job/main/block/service/service_test.go

@@ -0,0 +1,37 @@
+package service
+
+import (
+	"context"
+	"flag"
+	"os"
+	"testing"
+
+	"go-common/app/job/main/block/conf"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+var (
+	s *Service
+	c context.Context
+)
+
+func TestMain(m *testing.M) {
+	defer os.Exit(0)
+	flag.Set("conf", "../cmd/block-job-test.toml")
+	var err error
+	if err = conf.Init(); err != nil {
+		panic(err)
+	}
+	s = New()
+	defer s.Close()
+
+	m.Run()
+}
+
+func TestService(t *testing.T) {
+	Convey("", t, func() {
+		s.Ping(c)
+		s.Close()
+	})
+}