Create & Init Project...

app/service/live/zeus/internal/conf/BUILD

@@ -0,0 +1,40 @@
+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/service/live/zeus/internal/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/database/sql:go_default_library",
+        "//library/ecode/tip:go_default_library",
+        "//library/log:go_default_library",
+        "//library/net/http/blademaster:go_default_library",
+        "//library/net/http/blademaster/middleware/verify:go_default_library",
+        "//library/net/trace: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/service/live/zeus/internal/conf/conf.go

@@ -0,0 +1,103 @@
+package conf
+
+import (
+	"errors"
+	"flag"
+	"go-common/library/cache/memcache"
+	"go-common/library/cache/redis"
+	"go-common/library/database/sql"
+
+	"go-common/library/conf"
+	ecode "go-common/library/ecode/tip"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/net/http/blademaster/middleware/verify"
+	"go-common/library/net/trace"
+
+	"github.com/BurntSushi/toml"
+)
+
+var (
+	confPath string
+	client   *conf.Client
+	// Conf config
+	Conf = &Config{}
+)
+
+type IndexConfig struct {
+	Matcher string
+}
+
+type SvenConfig struct {
+	TreeID string
+	Zone   string
+	Env    string
+	Build  string
+	Token  string
+}
+
+// Config .
+type Config struct {
+	Log      *log.Config
+	BM       *bm.ServerConfig
+	Verify   *verify.Config
+	Tracer   *trace.Config
+	Redis    *redis.Config
+	Memcache *memcache.Config
+	MySQL    *sql.Config
+	Ecode    *ecode.Config
+	Sven     *SvenConfig
+	Index    *IndexConfig
+}
+
+func init() {
+	flag.StringVar(&confPath, "conf", "", "default 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
+	}
+	go func() {
+		for range client.Event() {
+			// Stupid code !
+			//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/service/live/zeus/internal/dao/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 = ["dao.go"],
+    importpath = "go-common/app/service/live/zeus/internal/dao",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/service/live/zeus/internal/conf:go_default_library",
+        "//library/cache/memcache:go_default_library",
+        "//library/cache/redis:go_default_library",
+        "//library/database/sql:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

app/service/live/zeus/internal/dao/dao.go

@@ -0,0 +1,42 @@
+package dao
+
+import (
+	"context"
+
+	"go-common/app/service/live/zeus/internal/conf"
+	"go-common/library/cache/memcache"
+	"go-common/library/cache/redis"
+	xsql "go-common/library/database/sql"
+)
+
+// Dao dao
+type Dao struct {
+	c     *conf.Config
+	mc    *memcache.Pool
+	redis *redis.Pool
+	db    *xsql.DB
+}
+
+// New init mysql db
+func New(c *conf.Config) (dao *Dao) {
+	dao = &Dao{
+		c: c,
+		//mc:    memcache.NewPool(c.Memcache),
+		//redis: redis.NewPool(c.Redis),
+		//db:    xsql.NewMySQL(c.MySQL),
+	}
+	return
+}
+
+// Close close the resource.
+func (d *Dao) Close() {
+	//d.mc.Close()
+	//d.redis.Close()
+	//d.db.Close()
+}
+
+// Ping dao ping
+func (d *Dao) Ping(ctx context.Context) error {
+	// TODO: add mc,redis... if you use
+	return d.db.Ping(ctx)
+}

app/service/live/zeus/internal/model/BUILD

@@ -0,0 +1,35 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "matcher.go",
+        "model.go",
+    ],
+    importpath = "go-common/app/service/live/zeus/internal/model",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/service/live/zeus/expr: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/service/live/zeus/internal/model/matcher.go

@@ -0,0 +1,80 @@
+package model
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"go-common/app/service/live/zeus/expr"
+	"go-common/library/log"
+)
+
+type Matcher struct {
+	Group             map[string][]*MatcherBucket `json:"group"`
+	VariableWhitelist []string                    `json:"variable_whitelist"`
+}
+
+type MatcherBucket struct {
+	RuleExpr string      `json:"expr"`
+	Extend   interface{} `json:"extend"`
+	expr     expr.Expr
+	variable []string
+	config   string
+}
+
+func NewMatcher(config string) (*Matcher, error) {
+	matcher := &Matcher{}
+	if err := json.Unmarshal([]byte(config), matcher); err != nil {
+		return nil, err
+	}
+	whitelist := make(map[string]struct{}, len(matcher.VariableWhitelist))
+	for _, v := range matcher.VariableWhitelist {
+		whitelist[v] = struct{}{}
+	}
+	parser := expr.NewExpressionParser()
+	for _, bucket := range matcher.Group {
+		for _, b := range bucket {
+			if e := parser.Parse(b.RuleExpr); e != nil {
+				msg := fmt.Sprintf("zeus compile error, rule:%s error:%s", b.RuleExpr, e.Error())
+				return nil, errors.New(msg)
+			}
+			b.expr = parser.GetExpr()
+			b.variable = parser.GetVariable()
+			for _, v := range b.variable {
+				if _, ok := whitelist[v]; !ok {
+					msg := fmt.Sprintf("zeus check error, rule:%s error: variable %s not in whitelist", b.RuleExpr, v)
+					return nil, errors.New(msg)
+				}
+			}
+			if config, e := json.Marshal(b.Extend); e != nil {
+				msg := fmt.Sprintf("zeus parse config error, rule:%s error:%s", b.RuleExpr, e.Error())
+				return nil, errors.New(msg)
+			} else {
+				b.config = string(config)
+			}
+		}
+	}
+	return matcher, nil
+}
+
+func (m *Matcher) Match(group string, env expr.Env) (bool, string, error) {
+	var bucket []*MatcherBucket
+	var ok bool
+	if bucket, ok = m.Group[group]; !ok {
+		return false, "", errors.New("group not found")
+	}
+	isMatch := false
+	extend := ""
+	for _, b := range bucket {
+		result, err := expr.EvalBool(b.expr, env)
+		if err != nil {
+			log.Error("zeus eval error, group:%s expr:%s error:%s", group, b.RuleExpr, err.Error())
+			continue
+		}
+		if result {
+			isMatch = true
+			extend = b.config
+			break
+		}
+	}
+	return isMatch, extend, nil
+}

app/service/live/zeus/internal/model/model.go

@@ -0,0 +1 @@
+package model

app/service/live/zeus/internal/server/grpc/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 = ["grpc.go"],
+    importpath = "go-common/app/service/live/zeus/internal/server/grpc",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/service/live/zeus/api/v1:go_default_library",
+        "//app/service/live/zeus/internal/conf:go_default_library",
+        "//app/service/live/zeus/internal/service/v1:go_default_library",
+        "//library/net/rpc/warden:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

app/service/live/zeus/internal/server/grpc/grpc.go

@@ -0,0 +1,18 @@
+package grpc
+
+import (
+	v1pb "go-common/app/service/live/zeus/api/v1"
+	"go-common/app/service/live/zeus/internal/conf"
+	v1srv "go-common/app/service/live/zeus/internal/service/v1"
+	"go-common/library/net/rpc/warden"
+)
+
+func New(c *conf.Config, s *v1srv.ZeusService) *warden.Server {
+	ws := warden.NewServer(nil)
+	v1pb.RegisterZeusServer(ws.Server(), s)
+	ws, err := ws.Start()
+	if err != nil {
+		panic(err)
+	}
+	return ws
+}

app/service/live/zeus/internal/server/http/BUILD

@@ -0,0 +1,37 @@
+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/service/live/zeus/internal/server/http",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/service/live/zeus/api/v1:go_default_library",
+        "//app/service/live/zeus/internal/conf:go_default_library",
+        "//app/service/live/zeus/internal/service:go_default_library",
+        "//app/service/live/zeus/internal/service/v1:go_default_library",
+        "//library/log:go_default_library",
+        "//library/net/http/blademaster:go_default_library",
+        "//library/net/http/blademaster/middleware/verify:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

app/service/live/zeus/internal/server/http/http.go

@@ -0,0 +1,56 @@
+package http
+
+import (
+	"net/http"
+
+	v1pb "go-common/app/service/live/zeus/api/v1"
+	"go-common/app/service/live/zeus/internal/conf"
+	"go-common/app/service/live/zeus/internal/service"
+	v1srv "go-common/app/service/live/zeus/internal/service/v1"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/net/http/blademaster/middleware/verify"
+)
+
+var (
+	vfy *verify.Verify
+	svc *service.Service
+)
+
+// Init init
+func Init(c *conf.Config, s *service.Service, zeus *v1srv.ZeusService) {
+	svc = s
+	vfy = verify.New(c.Verify)
+	engine := bm.DefaultServer(c.BM)
+	route(engine, zeus)
+	if err := engine.Start(); err != nil {
+		log.Error("bm Start error(%v)", err)
+		panic(err)
+	}
+}
+
+func route(e *bm.Engine, zeus *v1srv.ZeusService) {
+	e.Ping(ping)
+	e.Register(register)
+	g := e.Group("/x/zeus")
+	{
+		g.GET("/start", vfy.Verify, howToStart)
+	}
+	v1pb.RegisterZeusBMServer(e, zeus)
+}
+
+func ping(ctx *bm.Context) {
+	if err := svc.Ping(ctx); err != nil {
+		log.Error("ping error(%v)", err)
+		ctx.AbortWithStatus(http.StatusServiceUnavailable)
+	}
+}
+
+func register(c *bm.Context) {
+	c.JSON(map[string]interface{}{}, nil)
+}
+
+// example for http request handler
+func howToStart(c *bm.Context) {
+	c.String(0, "Golang 大法好 !!!")
+}

app/service/live/zeus/internal/service/BUILD

@@ -0,0 +1,41 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "match.go",
+        "service.go",
+    ],
+    importpath = "go-common/app/service/live/zeus/internal/service",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/service/live/zeus/expr:go_default_library",
+        "//app/service/live/zeus/internal/conf:go_default_library",
+        "//app/service/live/zeus/internal/dao:go_default_library",
+        "//app/service/live/zeus/internal/model: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",
+        "//app/service/live/zeus/internal/service/v1:all-srcs",
+    ],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

app/service/live/zeus/internal/service/match.go

@@ -0,0 +1,40 @@
+package service
+
+import (
+	"errors"
+	"go-common/app/service/live/zeus/expr"
+	"go-common/app/service/live/zeus/internal/model"
+	"go-common/library/log"
+	"sync/atomic"
+)
+
+type MatchService struct {
+	matcher atomic.Value
+}
+
+func NewMatchService(config string) (*MatchService, error) {
+	s := &MatchService{}
+	if err := s.Reload(config); err != nil {
+		return nil, err
+	}
+	return s, nil
+}
+
+func (m *MatchService) Reload(config string) error {
+	matcher, err := model.NewMatcher(config)
+	if err != nil {
+		log.Error("Match Service reload config failed, config:%s", config)
+		return err
+	}
+	m.matcher.Store(matcher)
+	log.Info("Match Service reload config success, config:%s", config)
+	return nil
+}
+
+func (m *MatchService) Match(group string, env expr.Env) (bool, string, error) {
+	matcher := m.matcher.Load().(*model.Matcher)
+	if matcher == nil {
+		return false, "", errors.New("matcher not initialized")
+	}
+	return matcher.Match(group, env)
+}

app/service/live/zeus/internal/service/service.go

@@ -0,0 +1,34 @@
+package service
+
+import (
+	"context"
+
+	"go-common/app/service/live/zeus/internal/conf"
+	"go-common/app/service/live/zeus/internal/dao"
+)
+
+// Service struct
+type Service struct {
+	c   *conf.Config
+	dao *dao.Dao
+}
+
+// New init
+func New(c *conf.Config) (s *Service) {
+	s = &Service{
+		c:   c,
+		dao: dao.New(c),
+	}
+	return s
+}
+
+// Ping Service
+func (s *Service) Ping(ctx context.Context) (err error) {
+	//return s.dao.Ping(ctx)
+	return nil
+}
+
+// Close Service
+func (s *Service) Close() {
+	s.dao.Close()
+}

app/service/live/zeus/internal/service/v1/BUILD

@@ -0,0 +1,37 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["zeus.go"],
+    importpath = "go-common/app/service/live/zeus/internal/service/v1",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/common/live/library/mengde:go_default_library",
+        "//app/service/live/zeus/api/v1:go_default_library",
+        "//app/service/live/zeus/expr:go_default_library",
+        "//app/service/live/zeus/internal/conf:go_default_library",
+        "//app/service/live/zeus/internal/service:go_default_library",
+        "//library/ecode: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/service/live/zeus/internal/service/v1/zeus.go

@@ -0,0 +1,70 @@
+package v1
+
+import (
+	"context"
+	"go-common/app/common/live/library/mengde"
+	v1pb "go-common/app/service/live/zeus/api/v1"
+	"go-common/app/service/live/zeus/expr"
+	"go-common/app/service/live/zeus/internal/conf"
+	"go-common/app/service/live/zeus/internal/service"
+	"go-common/library/ecode"
+	"go-common/library/log"
+)
+
+// ZeusService struct
+type ZeusService struct {
+	conf *conf.Config
+	// optionally add other properties here, such as dao
+	// dao *dao.Dao
+	mengde *mengde.MengdeClient
+	match  *service.MatchService
+}
+
+//NewZeusService init
+func NewZeusService(c *conf.Config) (s *ZeusService) {
+	mengde, err := mengde.NewMengdeClient(c.Sven.TreeID, c.Sven.Zone, c.Sven.Env, c.Sven.Build, c.Sven.Token)
+	if err != nil {
+		panic(err)
+	}
+	matcherConfig := mengde.Config().Config[c.Index.Matcher]
+	match, err := service.NewMatchService(matcherConfig)
+	if err != nil {
+		panic(err)
+	}
+	s = &ZeusService{
+		conf:   c,
+		mengde: mengde,
+		match:  match,
+	}
+	go s.configWatcher()
+	return s
+}
+
+func (s *ZeusService) configWatcher() {
+	for config := range s.mengde.ConfigNotify() {
+		if err := s.match.Reload(config.Config[s.conf.Index.Matcher]); err != nil {
+			log.Error("zeus reload error:%s", err.Error())
+		}
+	}
+}
+
+// Match implementation
+// `method:"POST"`
+func (s *ZeusService) Match(ctx context.Context, req *v1pb.MatchRequest) (*v1pb.MatchResponse, error) {
+	env := expr.Env{
+		"$build":    req.Build,
+		"$version":  req.Version,
+		"$buvid":    req.Buvid,
+		"$platform": req.Platform,
+		"$uid":      req.Uid,
+	}
+	isMatch, extend, err := s.match.Match(req.Group, env)
+	if err != nil {
+		return nil, ecode.Errorf(-1, err.Error())
+	}
+	resp := &v1pb.MatchResponse{
+		IsMatch: isMatch,
+		Extend:  extend,
+	}
+	return resp, nil
+}