) path can not be empty!")
20 | }
21 | projInfo.absPath = strings.TrimSpace(appPath)
22 | projInfo.absPath, err = filepath.Abs(projInfo.absPath)
23 | if err != nil {
24 | return errors.New("get absolute project path failed: %s!" + err.Error())
25 | }
26 | const SRC = "/src/"
27 | projInfo.absPath = strings.Replace(projInfo.absPath, `\`, `/`, -1)
28 | projInfo.absPath = strings.TrimRight(projInfo.absPath, "/")
29 | srcIdx := strings.Index(projInfo.absPath, SRC)
30 | if srcIdx == -1 {
31 | return errors.New("the project directory must be in the $GOPATH/src!")
32 | }
33 | projInfo.gopath = projInfo.absPath[:srcIdx]
34 | projInfo.projPath = projInfo.absPath[srcIdx+len(SRC):]
35 | projInfo.projName = projInfo.absPath[strings.LastIndex(projInfo.absPath, "/")+1:]
36 | projInfo.fileName = projInfo.projName
37 | if runtime.GOOS == "windows" {
38 | projInfo.fileName += ".exe"
39 | if old, ok := os.LookupEnv("GOPATH"); ok {
40 | projInfo.gopath += ";" + old
41 | }
42 | } else {
43 | if old, ok := os.LookupEnv("GOPATH"); ok {
44 | projInfo.gopath += ":" + old
45 | }
46 | }
47 | projInfo.rawCmdPath, _ = os.Getwd()
48 | return nil
49 | }
50 |
51 | // ProjName returns project name.
52 | func ProjName() string {
53 | return projInfo.projName
54 | }
55 |
56 | // FileName returns the binary execution file name.
57 | func FileName() string {
58 | return projInfo.fileName
59 | }
60 |
61 | // AbsPath returns the absolute project path.
62 | func AbsPath() string {
63 | return projInfo.absPath
64 | }
65 |
66 | // ProjPath returns the relative src project path.
67 | func ProjPath() string {
68 | return projInfo.projPath
69 | }
70 |
71 | // Gopath returns the current $GOPATH.
72 | func Gopath() string {
73 | return projInfo.gopath
74 | }
75 |
76 | // RawCmdPath returns the initial path to start.
77 | func RawCmdPath() string {
78 | return projInfo.rawCmdPath
79 | }
80 |
--------------------------------------------------------------------------------
/gateway/logic/business.go:
--------------------------------------------------------------------------------
1 | // Copyright 2018 github.com/xiaoenai. All Rights Reserved.
2 | //
3 | // Licensed under the Apache License, Version 2.0 (the "License");
4 | // you may not use this file except in compliance with the License.
5 | // You may obtain a copy of the License at
6 | //
7 | // http://www.apache.org/licenses/LICENSE-2.0
8 | //
9 | // Unless required by applicable law or agreed to in writing, software
10 | // distributed under the License is distributed on an "AS IS" BASIS,
11 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 | // See the License for the specific language governing permissions and
13 | // limitations under the License.
14 |
15 | package logic
16 |
17 | import (
18 | "github.com/henrylee2cn/erpc/v6"
19 | "github.com/henrylee2cn/erpc/v6/plugin/proxy"
20 | "github.com/xiaoenai/tp-micro/v6/gateway/types"
21 | )
22 |
23 | var (
24 | globalBusiness *types.Business
25 | apiVersion = "v6"
26 | )
27 |
28 | // SetBusiness sets business object.
29 | func SetBusiness(biz *types.Business) {
30 | if biz == nil {
31 | biz = types.DefaultBusiness()
32 | } else {
33 | biz.Init()
34 | }
35 | globalBusiness = biz
36 | }
37 |
38 | // SetApiVersion sets gateway API version.
39 | func SetApiVersion(ver string) {
40 | apiVersion = ver
41 | }
42 |
43 | // ApiVersion returns gateway API version.
44 | func ApiVersion() string {
45 | return apiVersion
46 | }
47 |
48 | // AuthFunc returns the authorization function for access behavior.
49 | func AuthFunc() types.AuthFunc {
50 | return globalBusiness.AuthFunc
51 | }
52 |
53 | // SocketHooks returns TCP socket connecting event hooks.
54 | func SocketHooks() types.SocketHooks {
55 | return globalBusiness.SocketHooks
56 | }
57 |
58 | // HttpHooks returns HTTP connecting event hooks.
59 | func HttpHooks() types.HttpHooks {
60 | return globalBusiness.HttpHooks
61 | }
62 |
63 | // WebSocketHooks returns WEB socket connecting event hooks.
64 | func WebSocketHooks() types.WebSocketHooks {
65 | return globalBusiness.WebSocketHooks
66 | }
67 |
68 | // ProxySelector returns proxy caller by label.
69 | func ProxySelector(label *proxy.Label) proxy.Forwarder {
70 | return globalBusiness.ProxySelector(label)
71 | }
72 |
73 | // InnerServerPlugins returns inner server plugins.
74 | func InnerServerPlugins() []erpc.Plugin {
75 | return globalBusiness.InnerServerPlugins
76 | }
77 |
--------------------------------------------------------------------------------
/gateway/types/business.go:
--------------------------------------------------------------------------------
1 | // Copyright 2018 github.com/xiaoenai. All Rights Reserved.
2 | //
3 | // Licensed under the Apache License, Version 2.0 (the "License");
4 | // you may not use this file except in compliance with the License.
5 | // You may obtain a copy of the License at
6 | //
7 | // http://www.apache.org/licenses/LICENSE-2.0
8 | //
9 | // Unless required by applicable law or agreed to in writing, software
10 | // distributed under the License is distributed on an "AS IS" BASIS,
11 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 | // See the License for the specific language governing permissions and
13 | // limitations under the License.
14 |
15 | package types
16 |
17 | import (
18 | "github.com/henrylee2cn/erpc/v6"
19 | "github.com/henrylee2cn/erpc/v6/plugin/proxy"
20 | "github.com/xiaoenai/tp-micro/v6/clientele"
21 | )
22 |
23 | // Business implement your real business logic
24 | type Business struct {
25 | // AuthFunc Verifies access token
26 | AuthFunc func(accessToken string) (AccessToken, *erpc.Status)
27 | // SocketHooks TCP socket connecting event hooks
28 | SocketHooks
29 | // HttpHooks HTTP connecting event hooks
30 | HttpHooks
31 | // WebSocketHooks WEB socket connecting event hooks
32 | WebSocketHooks
33 | // ProxySelector returns proxy caller by label.
34 | ProxySelector func(*proxy.Label) proxy.Forwarder
35 | // InnerServerPlugins inner server plugins
36 | InnerServerPlugins []erpc.Plugin
37 | }
38 |
39 | // DefaultBusiness creates a new default Business object.
40 | func DefaultBusiness() *Business {
41 | biz := new(Business)
42 | biz.Init()
43 | return biz
44 | }
45 |
46 | func (biz *Business) Init() {
47 | if biz.AuthFunc == nil {
48 | biz.AuthFunc = DefaultAuthFunc()
49 | }
50 | if biz.SocketHooks == nil {
51 | biz.SocketHooks = DefaultSocketHooks()
52 | }
53 | if biz.HttpHooks == nil {
54 | biz.HttpHooks = DefaultHttpHooks()
55 | }
56 | if biz.WebSocketHooks == nil {
57 | biz.WebSocketHooks = DefaultWebSocketHooks()
58 | }
59 | if biz.ProxySelector == nil {
60 | biz.ProxySelector = DefaultProxySelector()
61 | }
62 | }
63 |
64 | // DefaultProxySelector creates a new default proxy caller selector.
65 | func DefaultProxySelector() func(*proxy.Label) proxy.Forwarder {
66 | return func(*proxy.Label) proxy.Forwarder {
67 | return clientele.GetDynamicClient()
68 | }
69 | }
70 |
--------------------------------------------------------------------------------
/examples/project/logic/model/init.go:
--------------------------------------------------------------------------------
1 | package model
2 |
3 | import (
4 | "strings"
5 | "time"
6 |
7 | "github.com/xiaoenai/tp-micro/v6/model/mongo"
8 | "github.com/xiaoenai/tp-micro/v6/model/mysql"
9 | "github.com/xiaoenai/tp-micro/v6/model/redis"
10 | )
11 |
12 | // mysqlHandler preset mysql DB handler
13 | var mysqlHandler = mysql.NewPreDB()
14 |
15 | // mongoHandler preset mongo DB handler
16 | var mongoHandler = mongo.NewPreDB()
17 |
18 | var (
19 | redisClient *redis.Client
20 | cacheExpire time.Duration
21 | )
22 |
23 | // Init initializes the model packet.
24 | func Init(mysqlConfig *mysql.Config, mongoConfig *mongo.Config, redisConfig *redis.Config, _cacheExpire time.Duration) error {
25 | cacheExpire = _cacheExpire
26 | var err error
27 | if redisConfig != nil {
28 | redisClient, err = redis.NewClient(redisConfig)
29 | if err != nil {
30 | return err
31 | }
32 | }
33 | if mysqlConfig != nil {
34 | if err = mysqlHandler.Init2(mysqlConfig, redisClient); err != nil {
35 | return err
36 | }
37 | }
38 | if mongoConfig != nil {
39 | if err = mongoHandler.Init2(mongoConfig, redisClient); err != nil {
40 | return err
41 | }
42 | }
43 | return nil
44 | }
45 |
46 | // GetMysqlDB returns the mysql DB handler.
47 | func GetMysqlDB() *mysql.DB {
48 | return mysqlHandler.DB
49 | }
50 |
51 | // GetMongoDB returns the mongo DB handler.
52 | func GetMongoDB() *mongo.DB {
53 | return mongoHandler.DB
54 | }
55 |
56 | // GetRedis returns the redis client.
57 | func GetRedis() *redis.Client {
58 | return redisClient
59 | }
60 |
61 | func index(s string, sub ...string) int {
62 | var i, ii = -1, -1
63 | for _, ss := range sub {
64 | ii = strings.Index(s, ss)
65 | if ii != -1 && (ii < i || i == -1) {
66 | i = ii
67 | }
68 | }
69 | return i
70 | }
71 |
72 | func insertZeroDeletedTsField(whereCond string) string {
73 | whereCond = strings.TrimSpace(whereCond)
74 | whereCond = strings.TrimRight(whereCond, ";")
75 | i := index(
76 | whereCond,
77 | "`deleted_ts`",
78 | " deleted_ts",
79 | )
80 | if i != -1 {
81 | return whereCond
82 | }
83 | i = index(
84 | whereCond,
85 | "ORDER BY", "order by",
86 | "GROUP BY", "group by",
87 | "OFFSET", "offset",
88 | "LIMIT", "limit",
89 | )
90 | if i == -1 {
91 | return whereCond + " AND `deleted_ts`=0"
92 | }
93 | return whereCond[:i] + " AND `deleted_ts`=0 " + whereCond[i:]
94 | }
95 |
--------------------------------------------------------------------------------
/gateway/logic/socket/conn_tab.go:
--------------------------------------------------------------------------------
1 | // Copyright 2018 github.com/xiaoenai. All Rights Reserved.
2 | //
3 | // Licensed under the Apache License, Version 2.0 (the "License");
4 | // you may not use this file except in compliance with the License.
5 | // You may obtain a copy of the License at
6 | //
7 | // http://www.apache.org/licenses/LICENSE-2.0
8 | //
9 | // Unless required by applicable law or agreed to in writing, software
10 | // distributed under the License is distributed on an "AS IS" BASIS,
11 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 | // See the License for the specific language governing permissions and
13 | // limitations under the License.
14 |
15 | package socket
16 |
17 | import (
18 | "github.com/henrylee2cn/erpc/v6"
19 | "github.com/henrylee2cn/erpc/v6/plugin/auth"
20 | "github.com/xiaoenai/tp-micro/v6/gateway/logic"
21 | )
22 |
23 | type socketConnTab struct{}
24 |
25 | var (
26 | socketConnTabPlugin = (*socketConnTab)(nil)
27 | )
28 |
29 | var (
30 | _ erpc.PostReadCallBodyPlugin = socketConnTabPlugin
31 | _ erpc.PostReadPushBodyPlugin = socketConnTabPlugin
32 | _ erpc.PostDisconnectPlugin = socketConnTabPlugin
33 | )
34 |
35 | func (c *socketConnTab) Name() string {
36 | return "SocketConnTab"
37 | }
38 |
39 | func (c *socketConnTab) authAndLogon(authInfo string, sess auth.Session) *erpc.Status {
40 | token, stat := logic.AuthFunc()(authInfo)
41 | if stat != nil {
42 | return stat
43 | }
44 | info := token.AddedQuery()
45 | if info != nil && info.Len() > 0 {
46 | sess.Swap().Store(socketConnTabPlugin, info.String())
47 | }
48 | stat = logic.SocketHooks().OnLogon(sess, token)
49 | if stat == nil {
50 | erpc.Tracef("[+SOCKET_CONN] addr: %s, id: %s", sess.RemoteAddr().String(), sess.(erpc.BaseSession).ID())
51 | }
52 | return stat
53 | }
54 |
55 | func (c *socketConnTab) PostReadCallBody(ctx erpc.ReadCtx) *erpc.Status {
56 | _appendQuery, _ := ctx.Swap().Load(socketConnTabPlugin)
57 | appendQuery, _ := _appendQuery.(string)
58 | erpc.WithAddMeta("", appendQuery)
59 | return nil
60 | }
61 |
62 | func (c *socketConnTab) PostReadPushBody(ctx erpc.ReadCtx) *erpc.Status {
63 | return c.PostReadCallBody(ctx)
64 | }
65 |
66 | func (c *socketConnTab) PostDisconnect(sess erpc.BaseSession) *erpc.Status {
67 | erpc.Tracef("[-SOCKET_CONN] addr: %s, id: %s", sess.RemoteAddr().String(), sess.ID())
68 | return logic.SocketHooks().OnLogoff(sess)
69 | }
70 |
--------------------------------------------------------------------------------
/model/mongo/config.go:
--------------------------------------------------------------------------------
1 | package mongo
2 |
3 | import (
4 | "time"
5 |
6 | "github.com/henrylee2cn/cfgo"
7 | "gopkg.in/mgo.v2"
8 | )
9 |
10 | // Config mongodb setting
11 | type Config struct {
12 | Addrs []string `yaml:"addrs"`
13 | Timeout time.Duration `yaml:"timeout"`
14 | Database string `yaml:"database"`
15 | // Username and Password inform the credentials for the initial authentication
16 | // done on the database defined by the Source field. See Session.Login.
17 | Username string `yaml:"username"`
18 | Password string `yaml:"passward"`
19 | // PoolLimit defines the per-server socket pool limit. Defaults to 4096.
20 | // See Session.SetPoolLimit for details.
21 | PoolLimit int `yaml:"pool_limit"`
22 | // NoCache whether to disable cache
23 | NoCache bool `yaml:"no_cache"`
24 |
25 | init bool
26 | }
27 |
28 | var configs = make(map[string]*Config)
29 |
30 | // ReadConfig gets a mongodb db config form yaml.
31 | func ReadConfig(configSection string) (*Config, error) {
32 | conf, ok := configs[configSection]
33 | if ok {
34 | return conf, nil
35 | }
36 | conf = NewConfig()
37 | err := cfgo.Reg(configSection, conf)
38 | if err == nil {
39 | configs[configSection] = conf
40 | return conf, nil
41 | } else {
42 | return nil, err
43 | }
44 | }
45 |
46 | // NewConfig creates a default config.
47 | func NewConfig() *Config {
48 | return &Config{
49 | Addrs: []string{"127.0.0.1:27017"},
50 | Timeout: 10,
51 | PoolLimit: 256,
52 | Username: "root",
53 | Password: "",
54 | Database: "test",
55 | }
56 | }
57 |
58 | // Reload sync automatically config from config file.
59 | func (cfg *Config) Reload(bind cfgo.BindFunc) error {
60 | if cfg.init {
61 | return nil
62 | }
63 | err := bind()
64 | if err != nil {
65 | return err
66 | }
67 | if len(cfg.Addrs) == 0 {
68 | cfg.Addrs = []string{"127.0.0.1:27017"}
69 | }
70 | if len(cfg.Username) == 0 {
71 | cfg.Username = "root"
72 | }
73 | if len(cfg.Database) == 0 {
74 | cfg.Database = "test"
75 | }
76 | cfg.init = true
77 | return nil
78 | }
79 |
80 | // Set config
81 | func (mgoConfig *Config) Source() *mgo.DialInfo {
82 | dialInfo := &mgo.DialInfo{
83 | Addrs: mgoConfig.Addrs,
84 | Username: mgoConfig.Username,
85 | Password: mgoConfig.Password,
86 | Database: mgoConfig.Database,
87 | Timeout: mgoConfig.Timeout,
88 | PoolLimit: mgoConfig.PoolLimit,
89 | }
90 |
91 | return dialInfo
92 | }
93 |
--------------------------------------------------------------------------------
/gateway/logic/websocket/conn_tab.go:
--------------------------------------------------------------------------------
1 | // Copyright 2019 github.com/xiaoenai. All Rights Reserved.
2 | //
3 | // Licensed under the Apache License, Version 2.0 (the "License");
4 | // you may not use this file except in compliance with the License.
5 | // You may obtain a copy of the License at
6 | //
7 | // http://www.apache.org/licenses/LICENSE-2.0
8 | //
9 | // Unless required by applicable law or agreed to in writing, software
10 | // distributed under the License is distributed on an "AS IS" BASIS,
11 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 | // See the License for the specific language governing permissions and
13 | // limitations under the License.
14 |
15 | package websocket
16 |
17 | import (
18 | "github.com/henrylee2cn/erpc/v6"
19 | "github.com/henrylee2cn/erpc/v6/plugin/auth"
20 | "github.com/xiaoenai/tp-micro/v6/gateway/logic"
21 | )
22 |
23 | type webSocketConnTab struct{}
24 |
25 | var (
26 | webSocketConnTabPlugin = (*webSocketConnTab)(nil)
27 | )
28 |
29 | var (
30 | _ erpc.PostReadCallBodyPlugin = webSocketConnTabPlugin
31 | _ erpc.PostReadPushBodyPlugin = webSocketConnTabPlugin
32 | _ erpc.PostDisconnectPlugin = webSocketConnTabPlugin
33 | )
34 |
35 | func (c *webSocketConnTab) Name() string {
36 | return "WebSocketConnTab"
37 | }
38 |
39 | func (c *webSocketConnTab) authAndLogon(authInfo string, sess auth.Session) *erpc.Status {
40 | token, stat := logic.AuthFunc()(authInfo)
41 | if stat != nil {
42 | return stat
43 | }
44 | info := token.AddedQuery()
45 | if info != nil && info.Len() > 0 {
46 | sess.Swap().Store(webSocketConnTabPlugin, info.String())
47 | }
48 | stat = logic.WebSocketHooks().OnLogon(sess, token)
49 | if stat == nil {
50 | erpc.Tracef("[+SOCKET_CONN] addr: %s, id: %s", sess.RemoteAddr().String(), sess.(erpc.BaseSession).ID())
51 | }
52 | return stat
53 | }
54 |
55 | func (c *webSocketConnTab) PostReadCallBody(ctx erpc.ReadCtx) *erpc.Status {
56 | _appendQuery, _ := ctx.Swap().Load(webSocketConnTabPlugin)
57 | appendQuery, _ := _appendQuery.(string)
58 | erpc.WithAddMeta("", appendQuery)
59 | return nil
60 | }
61 |
62 | func (c *webSocketConnTab) PostReadPushBody(ctx erpc.ReadCtx) *erpc.Status {
63 | return c.PostReadCallBody(ctx)
64 | }
65 |
66 | func (c *webSocketConnTab) PostDisconnect(sess erpc.BaseSession) *erpc.Status {
67 | erpc.Tracef("[-WEBSOCKET_CONN] addr: %s, id: %s", sess.RemoteAddr().String(), sess.ID())
68 | return logic.WebSocketHooks().OnLogoff(sess)
69 | }
70 |
--------------------------------------------------------------------------------
/gateway/types/auth.go:
--------------------------------------------------------------------------------
1 | // Copyright 2018 github.com/xiaoenai. All Rights Reserved.
2 | //
3 | // Licensed under the Apache License, Version 2.0 (the "License");
4 | // you may not use this file except in compliance with the License.
5 | // You may obtain a copy of the License at
6 | //
7 | // http://www.apache.org/licenses/LICENSE-2.0
8 | //
9 | // Unless required by applicable law or agreed to in writing, software
10 | // distributed under the License is distributed on an "AS IS" BASIS,
11 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 | // See the License for the specific language governing permissions and
13 | // limitations under the License.
14 |
15 | package types
16 |
17 | import (
18 | "github.com/henrylee2cn/erpc/v6"
19 | "github.com/henrylee2cn/erpc/v6/utils"
20 | )
21 |
22 | type (
23 | // AuthFunc Verifies access token
24 | AuthFunc func(authInfo string) (AccessToken, *erpc.Status)
25 | // AccessToken access token info
26 | AccessToken interface {
27 | // String returns the access token string.
28 | String() string
29 | // SessionId specifies the string as the session ID.
30 | SessionId() string
31 | // Uid returns the user id.
32 | Uid() string
33 | // DeviceId returns the device id.
34 | DeviceId() string
35 | // AddedQuery the user information will be appended to the URI query part.
36 | AddedQuery() *utils.Args
37 | }
38 | )
39 |
40 | // DefaultAuthFunc returns the default authorization function for access behavior.
41 | func DefaultAuthFunc() AuthFunc {
42 | return defAuthFunc
43 | }
44 |
45 | func defAuthFunc(authInfo string) (AccessToken, *erpc.Status) {
46 | return defAccessToken(authInfo), nil
47 | }
48 |
49 | type defAccessToken string
50 |
51 | // String returns the access token string.
52 | func (d defAccessToken) String() string {
53 | return string(d)
54 | }
55 |
56 | // SessionId specifies the string as the session ID.
57 | func (d defAccessToken) SessionId() string {
58 | return string(d)
59 | }
60 |
61 | // Uid returns the user id.
62 | func (d defAccessToken) Uid() string {
63 | return string(d)
64 | }
65 |
66 | // DeviceId returns the device id.
67 | func (d defAccessToken) DeviceId() string {
68 | return string(d)
69 | }
70 |
71 | type ctx struct{ erpc.UnknownPushCtx }
72 |
73 | // AddedQuery the user information will be appended to the URI query part.
74 | func (d defAccessToken) AddedQuery() *utils.Args {
75 | args := utils.AcquireArgs()
76 | args.Set("_uid", d.Uid())
77 | args.Set("_device_id", d.DeviceId())
78 | return args
79 | }
80 |
--------------------------------------------------------------------------------
/micro/create/create.go:
--------------------------------------------------------------------------------
1 | package create
2 |
3 | import (
4 | "io/ioutil"
5 | "os"
6 | "strings"
7 |
8 | "github.com/henrylee2cn/erpc/v6"
9 | "github.com/henrylee2cn/goutil"
10 | "github.com/xiaoenai/tp-micro/v6/micro/create/tpl"
11 | "github.com/xiaoenai/tp-micro/v6/micro/info"
12 | )
13 |
14 | // MicroTpl template file name
15 | const MicroTpl = "__tp-micro__tpl__.go"
16 |
17 | // MicroGenLock the file is used to markup generated project
18 | const MicroGenLock = "__tp-micro__gen__.lock"
19 |
20 | // CreateProject creates a project.
21 | func CreateProject(force, newdoc bool) {
22 | erpc.Infof("Generating project: %s", info.ProjPath())
23 |
24 | os.MkdirAll(info.AbsPath(), os.FileMode(0755))
25 | err := os.Chdir(info.AbsPath())
26 | if err != nil {
27 | erpc.Fatalf("[micro] Jump working directory failed: %v", err)
28 | }
29 |
30 | force = force || !goutil.FileExists(MicroGenLock)
31 |
32 | // creates base files
33 | if force {
34 | tpl.Create()
35 | }
36 |
37 | // read temptale file
38 | b, err := ioutil.ReadFile(MicroTpl)
39 | if err != nil {
40 | b = []byte(strings.Replace(__tpl__, "__PROJ_NAME__", info.ProjName(), -1))
41 | }
42 |
43 | // new project code
44 | proj := NewProject(b)
45 | proj.Generator(force, force || newdoc)
46 |
47 | // write template file
48 | f, err := os.OpenFile(MicroTpl, os.O_WRONLY|os.O_TRUNC|os.O_CREATE, os.ModePerm)
49 | if err != nil {
50 | erpc.Fatalf("[micro] Create files error: %v", err)
51 | }
52 | defer f.Close()
53 | f.Write(formatSource(b))
54 |
55 | tpl.RestoreAsset("./", MicroGenLock)
56 |
57 | erpc.Infof("Completed code generation!")
58 | }
59 |
60 | // CreateDoc creates a project doc.
61 | func CreateDoc() {
62 | erpc.Infof("Generating README.md: %s", info.ProjPath())
63 |
64 | os.MkdirAll(info.AbsPath(), os.FileMode(0755))
65 | err := os.Chdir(info.AbsPath())
66 | if err != nil {
67 | erpc.Fatalf("[micro] Jump working directory failed: %v", err)
68 | }
69 |
70 | // read temptale file
71 | b, err := ioutil.ReadFile(MicroTpl)
72 | if err != nil {
73 | b = []byte(strings.Replace(__tpl__, "__PROJ_NAME__", info.ProjName(), -1))
74 | }
75 |
76 | // new project code
77 | proj := NewProject(b)
78 | proj.gen()
79 | proj.genAndWriteReadmeFile()
80 |
81 | // write template file
82 | f, err := os.OpenFile(MicroTpl, os.O_WRONLY|os.O_TRUNC|os.O_CREATE, os.ModePerm)
83 | if err != nil {
84 | erpc.Fatalf("[micro] Create files error: %v", err)
85 | }
86 | defer f.Close()
87 | f.Write(formatSource(b))
88 |
89 | erpc.Infof("Completed README.md generation!")
90 | }
91 |
--------------------------------------------------------------------------------
/gateway/helper/gray/logic/logic.go:
--------------------------------------------------------------------------------
1 | package logic
2 |
3 | import (
4 | "regexp"
5 |
6 | "github.com/henrylee2cn/goutil"
7 | "github.com/henrylee2cn/erpc/v6"
8 | micro "github.com/xiaoenai/tp-micro/v6"
9 |
10 | "github.com/xiaoenai/tp-micro/v6/gateway/helper/gray/logic/model"
11 | "github.com/xiaoenai/tp-micro/v6/gateway/helper/gray/types"
12 | )
13 |
14 | var (
15 | regexpCache = goutil.AtomicMap()
16 | notGrayResult = new(types.IsGrayResult)
17 | isGrayResult = &types.IsGrayResult{
18 | Gray: true,
19 | }
20 | )
21 |
22 | // IsGray check whether the service should use grayscale based on the uid.
23 | func IsGray(args *types.IsGrayArgs) (*types.IsGrayResult, *erpc.Status) {
24 | g, exist, err := model.GetGrayMatchByUri(args.Uri)
25 | if err != nil {
26 | return nil, micro.RerrInternalServerError.SetCause(err.Error())
27 | }
28 | if !exist {
29 | return notGrayResult, nil
30 | }
31 | var re *regexp.Regexp
32 | reIface, ok := regexpCache.Load(g.Regexp)
33 | if !ok {
34 | re, err = regexp.Compile(g.Regexp)
35 | if err != nil {
36 | return nil, micro.RerrInternalServerError.SetCause(err.Error())
37 | }
38 | regexpCache.Store(g.Regexp, re)
39 | } else {
40 | re = reIface.(*regexp.Regexp)
41 | }
42 | if re.MatchString(args.Uid) {
43 | return isGrayResult, nil
44 | }
45 | return notGrayResult, nil
46 | }
47 |
48 | // Get get the rule of gray.
49 | func Get(args *types.GetArgs) (*types.GrayMatch, *erpc.Status) {
50 | g, exist, err := model.GetGrayMatchByUri(args.Uri)
51 | if err != nil {
52 | return nil, micro.RerrInternalServerError.SetCause(err.Error())
53 | }
54 | if !exist {
55 | return nil, micro.RerrNotFound
56 | }
57 | return g, nil
58 | }
59 |
60 | // Delete delete the rule of gray.
61 | func Delete(args *types.DeleteArgs) (*struct{}, *erpc.Status) {
62 | err := model.DeleteGrayMatchByUri(args.Uri)
63 | if err != nil {
64 | return nil, micro.RerrInternalServerError.SetCause(err.Error())
65 | }
66 | return new(struct{}), nil
67 | }
68 |
69 | // Set insert or update the regular expression for matching the URI.
70 | func Set(args *types.SetArgs) (*struct{}, *erpc.Status) {
71 | _, ok := regexpCache.Load(args.Regexp)
72 | if !ok {
73 | re, err := regexp.Compile(args.Regexp)
74 | if err != nil {
75 | return nil, micro.RerrInvalidParameter.SetCause(err.Error())
76 | }
77 | regexpCache.Store(args.Regexp, re)
78 | }
79 | // put
80 | err := model.UpsertGrayMatch(&model.GrayMatch{
81 | Uri: args.Uri,
82 | Regexp: args.Regexp,
83 | })
84 | if err != nil {
85 | return nil, micro.RerrInternalServerError.SetCause(err.Error())
86 | }
87 | return new(struct{}), nil
88 | }
89 |
--------------------------------------------------------------------------------
/gateway/helper/gray/gray.go:
--------------------------------------------------------------------------------
1 | package gray
2 |
3 | import (
4 | "strings"
5 |
6 | "github.com/henrylee2cn/erpc/v6"
7 | "github.com/henrylee2cn/erpc/v6/plugin/proxy"
8 | micro "github.com/xiaoenai/tp-micro/v6"
9 | "github.com/xiaoenai/tp-micro/v6/clientele"
10 | "github.com/xiaoenai/tp-micro/v6/discovery"
11 | "github.com/xiaoenai/tp-micro/v6/gateway/helper/gray/api"
12 | "github.com/xiaoenai/tp-micro/v6/gateway/helper/gray/logic"
13 | mod "github.com/xiaoenai/tp-micro/v6/gateway/helper/gray/logic/model"
14 | types "github.com/xiaoenai/tp-micro/v6/gateway/helper/gray/types"
15 | gwLogic "github.com/xiaoenai/tp-micro/v6/gateway/logic"
16 | gwTypes "github.com/xiaoenai/tp-micro/v6/gateway/types"
17 | "github.com/xiaoenai/tp-micro/v6/model/etcd"
18 | "github.com/xiaoenai/tp-micro/v6/model/mysql"
19 | "github.com/xiaoenai/tp-micro/v6/model/redis"
20 | )
21 |
22 | // SetGray sets gray model to *gwTypes.Business.
23 | // Note: the result grayClient may be used externally.
24 | func SetGray(
25 | biz *gwTypes.Business,
26 | grayClientConfig micro.CliConfig,
27 | grayEtcdConfig etcd.EasyConfig,
28 | mysqlConfig mysql.Config,
29 | redisConfig redis.Config,
30 | protoFunc erpc.ProtoFunc,
31 | ) (grayClient *micro.Client, err error) {
32 | err = mod.Init(mysqlConfig, redisConfig)
33 | if err != nil {
34 | return nil, err
35 | }
36 | // if protoFunc == nil {
37 | // protoFunc = socket.NewRawProtoFunc
38 | // }
39 | grayEtcdClient, err := etcd.EasyNew(grayEtcdConfig)
40 | if err != nil {
41 | return nil, err
42 | }
43 | grayClient = micro.NewClient(
44 | grayClientConfig,
45 | discovery.NewLinkerFromEtcd(grayEtcdClient),
46 | )
47 | grayClient.SetProtoFunc(protoFunc)
48 |
49 | biz.InnerServerPlugins = append(biz.InnerServerPlugins, new(innerServerPlugin))
50 | biz.ProxySelector = func(label *proxy.Label) proxy.Forwarder {
51 | idx := strings.Index(label.ServiceMethod, "?")
52 | var uri string
53 | if idx != -1 {
54 | uri = label.ServiceMethod[:idx]
55 | } else {
56 | uri = label.ServiceMethod
57 | }
58 | r, stat := logic.IsGray(&types.IsGrayArgs{
59 | Uri: uri,
60 | Uid: label.SessionID,
61 | })
62 | if stat != nil {
63 | erpc.Errorf("%s", stat.String())
64 | return clientele.GetDynamicClient()
65 | }
66 | if !r.Gray {
67 | return clientele.GetDynamicClient()
68 | }
69 | return grayClient
70 | }
71 | return grayClient, nil
72 | }
73 |
74 | type innerServerPlugin struct{}
75 |
76 | func (*innerServerPlugin) Name() string {
77 | return "route_gray"
78 | }
79 |
80 | var _ erpc.PostNewPeerPlugin = (*innerServerPlugin)(nil)
81 |
82 | func (*innerServerPlugin) PostNewPeer(peer erpc.EarlyPeer) error {
83 | api.Route("/gw/"+gwLogic.ApiVersion()+"/gray", peer.Router())
84 | return nil
85 | }
86 |
--------------------------------------------------------------------------------
/model/mysql/values.go:
--------------------------------------------------------------------------------
1 | package mysql
2 |
3 | import (
4 | "database/sql/driver"
5 | "encoding/json"
6 | )
7 |
8 | var (
9 | emptyObjectValue = []byte("{}")
10 | emptyArrayValue = []byte("[]")
11 | )
12 |
13 | // Int32s db column value type.
14 | type Int32s []int32
15 |
16 | // Scan implements the sql.Scanner interface.
17 | func (i *Int32s) Scan(value interface{}) error {
18 | data, ok := value.([]byte)
19 | if !ok {
20 | return nil
21 | }
22 | return json.Unmarshal(data, i)
23 | }
24 |
25 | // Value implements the driver.Valuer interface.
26 | func (i Int32s) Value() (driver.Value, error) {
27 | if i == nil {
28 | return emptyArrayValue, nil
29 | }
30 | return json.Marshal(i)
31 | }
32 |
33 | // Int64s db column value type.
34 | type Int64s []int64
35 |
36 | // Scan implements the sql.Scanner interface.
37 | func (i *Int64s) Scan(value interface{}) error {
38 | data, ok := value.([]byte)
39 | if !ok {
40 | return nil
41 | }
42 | return json.Unmarshal(data, i)
43 | }
44 |
45 | // Value implements the driver.Valuer interface.
46 | func (i Int64s) Value() (driver.Value, error) {
47 | if i == nil {
48 | return emptyArrayValue, nil
49 | }
50 | return json.Marshal(i)
51 | }
52 |
53 | // Strings db column value type.
54 | type Strings []string
55 |
56 | // Scan implements the sql.Scanner interface.
57 | func (s *Strings) Scan(value interface{}) error {
58 | data, ok := value.([]byte)
59 | if !ok {
60 | return nil
61 | }
62 | return json.Unmarshal(data, s)
63 | }
64 |
65 | // Value implements the driver.Valuer interface.
66 | func (s Strings) Value() (driver.Value, error) {
67 | if s == nil {
68 | return emptyArrayValue, nil
69 | }
70 | return json.Marshal(s)
71 | }
72 |
73 | // Int8IFaceMap db column value type.
74 | type Int8IFaceMap map[int8]interface{}
75 |
76 | // Scan implements the sql.Scanner interface.
77 | func (i *Int8IFaceMap) Scan(value interface{}) error {
78 | data, ok := value.([]byte)
79 | if !ok {
80 | return nil
81 | }
82 | return json.Unmarshal(data, i)
83 | }
84 |
85 | // Value implements the driver.Valuer interface.
86 | func (i Int8IFaceMap) Value() (driver.Value, error) {
87 | if i == nil {
88 | return emptyObjectValue, nil
89 | }
90 | return json.Marshal(i)
91 | }
92 |
93 | // IntStringMap db column value type.
94 | type IntStringMap map[int]string
95 |
96 | // Scan implements the sql.Scanner interface.
97 | func (i *IntStringMap) Scan(value interface{}) error {
98 | data, ok := value.([]byte)
99 | if !ok {
100 | return nil
101 | }
102 | return json.Unmarshal(data, i)
103 | }
104 |
105 | // Value implements the driver.Valuer interface.
106 | func (i IntStringMap) Value() (driver.Value, error) {
107 | if i == nil {
108 | return emptyObjectValue, nil
109 | }
110 | return json.Marshal(i)
111 | }
112 |
--------------------------------------------------------------------------------
/micro/run/fsnotify/fsnotify.go:
--------------------------------------------------------------------------------
1 | // Copyright 2012 The Go Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style
3 | // license that can be found in the LICENSE file.
4 |
5 | // Package fsnotify implements file system notification.
6 | package fsnotify
7 |
8 | import "fmt"
9 |
10 | const (
11 | FSN_CREATE = 1
12 | FSN_MODIFY = 2
13 | FSN_DELETE = 4
14 | FSN_RENAME = 8
15 |
16 | FSN_ALL = FSN_MODIFY | FSN_DELETE | FSN_RENAME | FSN_CREATE
17 | )
18 |
19 | // Purge events from interal chan to external chan if passes filter
20 | func (w *Watcher) purgeEvents() {
21 | for ev := range w.internalEvent {
22 | sendEvent := false
23 | w.fsnmut.Lock()
24 | fsnFlags := w.fsnFlags[ev.Name]
25 | w.fsnmut.Unlock()
26 |
27 | if (fsnFlags&FSN_CREATE == FSN_CREATE) && ev.IsCreate() {
28 | sendEvent = true
29 | }
30 |
31 | if (fsnFlags&FSN_MODIFY == FSN_MODIFY) && ev.IsModify() {
32 | sendEvent = true
33 | }
34 |
35 | if (fsnFlags&FSN_DELETE == FSN_DELETE) && ev.IsDelete() {
36 | sendEvent = true
37 | }
38 |
39 | if (fsnFlags&FSN_RENAME == FSN_RENAME) && ev.IsRename() {
40 | sendEvent = true
41 | }
42 |
43 | if sendEvent {
44 | w.Event <- ev
45 | }
46 |
47 | // If there's no file, then no more events for user
48 | // BSD must keep watch for internal use (watches DELETEs to keep track
49 | // what files exist for create events)
50 | if ev.IsDelete() {
51 | w.fsnmut.Lock()
52 | delete(w.fsnFlags, ev.Name)
53 | w.fsnmut.Unlock()
54 | }
55 | }
56 |
57 | close(w.Event)
58 | }
59 |
60 | // Watch a given file path
61 | func (w *Watcher) Watch(path string) error {
62 | return w.WatchFlags(path, FSN_ALL)
63 | }
64 |
65 | // Watch a given file path for a particular set of notifications (FSN_MODIFY etc.)
66 | func (w *Watcher) WatchFlags(path string, flags uint32) error {
67 | w.fsnmut.Lock()
68 | w.fsnFlags[path] = flags
69 | w.fsnmut.Unlock()
70 | return w.watch(path)
71 | }
72 |
73 | // Remove a watch on a file
74 | func (w *Watcher) RemoveWatch(path string) error {
75 | w.fsnmut.Lock()
76 | delete(w.fsnFlags, path)
77 | w.fsnmut.Unlock()
78 | return w.removeWatch(path)
79 | }
80 |
81 | // String formats the event e in the form
82 | // "filename: DELETE|MODIFY|..."
83 | func (e *FileEvent) String() string {
84 | var events string = ""
85 |
86 | if e.IsCreate() {
87 | events += "|" + "CREATE"
88 | }
89 |
90 | if e.IsDelete() {
91 | events += "|" + "DELETE"
92 | }
93 |
94 | if e.IsModify() {
95 | events += "|" + "MODIFY"
96 | }
97 |
98 | if e.IsRename() {
99 | events += "|" + "RENAME"
100 | }
101 |
102 | if e.IsAttrib() {
103 | events += "|" + "ATTRIB"
104 | }
105 |
106 | if len(events) > 0 {
107 | events = events[1:]
108 | }
109 |
110 | return fmt.Sprintf("%q: %s", e.Name, events)
111 | }
112 |
--------------------------------------------------------------------------------
/model/mysql/README.md:
--------------------------------------------------------------------------------
1 | # mysql
2 |
3 | A mysql ORM(Object Role Modeling) package with redis cache.
4 |
5 | ## Example
6 |
7 | ```go
8 | import (
9 | "encoding/json"
10 | "testing"
11 | "time"
12 |
13 | "github.com/xiaoenai/tp-micro/v6/model/mysql"
14 | "github.com/xiaoenai/tp-micro/v6/model/redis"
15 | )
16 |
17 | type testTable struct {
18 | TestId int64
19 | TestContent string
20 | Deleted bool `db:"test_deleted"`
21 | }
22 |
23 | func (t *testTable) TableName() string {
24 | return "test_table"
25 | }
26 |
27 | func TestCacheDb(t *testing.T) {
28 | dbConf, err := mysql.ReadConfig("test_db")
29 | if err != nil {
30 | t.Fatal(err)
31 | }
32 | dbConf.Database = "test"
33 | redisConf, err := redis.ReadConfig("test_redis")
34 | if err != nil {
35 | t.Fatal(err)
36 | }
37 | db, err := mysql.Connect(dbConf, redisConf)
38 | if err != nil {
39 | t.Fatal(err)
40 | }
41 | _, err = db.Exec("CREATE TABLE IF NOT EXISTS `dbtest` (`test_id` INT(10) AUTO_INCREMENT, `test_content` VARCHAR(20), `test_deleted` TINYINT(2), PRIMARY KEY(`test_id`)) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='测试表'")
42 | if err != nil {
43 | t.Fatal(err)
44 | }
45 | c, err := db.RegCacheableDB(new(testTable), time.Second)
46 | if err != nil {
47 | t.Fatal(err)
48 | }
49 | obj := &testTable{
50 | TestId: 1,
51 | TestContent: "abc",
52 | Deleted: false,
53 | }
54 | _, err = c.NamedExec("INSERT INTO dbtest (test_id,test_content,test_deleted)VALUES(:test_id,:test_content,:test_deleted) ON DUPLICATE KEY UPDATE test_id=:test_id", obj)
55 | if err != nil {
56 | t.Fatal(err)
57 | }
58 |
59 | // query and cache
60 | dest := &testTable{TestId: 1}
61 | err = c.CacheGet(dest)
62 | if err != nil {
63 | t.Fatal(err)
64 | }
65 | t.Logf("first:%#v", dest)
66 |
67 | // verify the cache
68 | cacheKey, _, err := c.CreateCacheKey(dest)
69 | t.Logf("cacheKey:%#v", cacheKey)
70 | key := cacheKey.Key
71 | if err != nil {
72 | t.Fatal(err)
73 | }
74 | b, err := c.Cache.Get(key).Bytes()
75 | if err != nil {
76 | t.Fatal(err)
77 | }
78 | var v1 = new(testTable)
79 | err = json.Unmarshal(b, v1)
80 | if err != nil {
81 | t.Fatal(err)
82 | }
83 | t.Logf("cache of before expiring: %+v", v1)
84 |
85 | time.Sleep(2 * time.Second)
86 |
87 | b, err = c.Cache.Get(key).Bytes()
88 | if err == nil {
89 | var v2 = new(testTable)
90 | err = json.Unmarshal(b, v2)
91 | if err != nil {
92 | t.Fatal(err)
93 | }
94 | t.Fatalf("expired but not deleted: %#v", v2)
95 | }
96 | t.Logf("expired cache error: %v", err)
97 | }
98 | ```
99 |
100 | ```sh
101 | go test -v -run=TestCacheDb
102 | ```
--------------------------------------------------------------------------------
/model/mysql/config.go:
--------------------------------------------------------------------------------
1 | package mysql
2 |
3 | import (
4 | "fmt"
5 |
6 | _ "github.com/go-sql-driver/mysql"
7 | "github.com/henrylee2cn/cfgo"
8 | )
9 |
10 | // Config db config
11 | type Config struct {
12 | Database string
13 | Username string
14 | Password string
15 | Host string
16 | Port int
17 | // the maximum number of connections in the idle connection pool.
18 | //
19 | // If MaxOpenConns is greater than 0 but less than the new MaxIdleConns
20 | // then the new MaxIdleConns will be reduced to match the MaxOpenConns limit
21 | //
22 | // If n <= 0, no idle connections are retained.
23 | MaxIdleConns int `yaml:"max_idle_conns"`
24 | // the maximum number of open connections to the database.
25 | // If MaxIdleConns is greater than 0 and the new MaxOpenConns is less than
26 | // MaxIdleConns, then MaxIdleConns will be reduced to match the new
27 | // MaxOpenConns limit
28 | //
29 | // If n <= 0, then there is no limit on the number of open connections.
30 | // The default is 0 (unlimited).
31 | MaxOpenConns int `yaml:"max_open_conns"`
32 | // maximum amount of second a connection may be reused.
33 | // If d <= 0, connections are reused forever.
34 | ConnMaxLifetime int64 `yaml:"conn_max_lifetime"`
35 |
36 | // NoCache whether to disable cache
37 | NoCache bool `yaml:"no_cache"`
38 |
39 | init bool
40 | }
41 |
42 | var configs = make(map[string]*Config)
43 |
44 | // ReadConfig gets a mysql db config form yaml.
45 | func ReadConfig(configSection string) (*Config, error) {
46 | conf, ok := configs[configSection]
47 | if ok {
48 | return conf, nil
49 | }
50 | conf = NewConfig()
51 | err := cfgo.Reg(configSection, conf)
52 | if err == nil {
53 | configs[configSection] = conf
54 | return conf, nil
55 | } else {
56 | return nil, err
57 | }
58 | }
59 |
60 | // NewConfig creates a default config.
61 | func NewConfig() *Config {
62 | return &Config{
63 | Host: "127.0.0.1",
64 | Port: 3306,
65 | Username: "root",
66 | Database: "test",
67 | }
68 | }
69 |
70 | // Source returns the mysql connection string.
71 | func (cfg *Config) Source() string {
72 | pwd := cfg.Password
73 | if pwd != "" {
74 | pwd = ":" + pwd
75 | }
76 | port := cfg.Port
77 | if port == 0 {
78 | port = 3306
79 | }
80 | return fmt.Sprintf("%s%s@tcp(%s:%d)/%s?charset=utf8mb4&parseTime=true&loc=Local&interpolateParams=true", cfg.Username, pwd, cfg.Host, port, cfg.Database)
81 | }
82 |
83 | // Reload sync automatically config from config file.
84 | func (cfg *Config) Reload(bind cfgo.BindFunc) error {
85 | if cfg.init {
86 | return nil
87 | }
88 | err := bind()
89 | if err != nil {
90 | return err
91 | }
92 | if len(cfg.Host) == 0 {
93 | cfg.Host = "127.0.0.1"
94 | }
95 | if cfg.Port <= 0 {
96 | cfg.Port = 3306
97 | }
98 | if len(cfg.Username) == 0 {
99 | cfg.Username = "root"
100 | }
101 | if len(cfg.Database) == 0 {
102 | cfg.Database = "test"
103 | }
104 | cfg.init = true
105 | return nil
106 | }
107 |
--------------------------------------------------------------------------------
/model/mysql/pre_db.go:
--------------------------------------------------------------------------------
1 | package mysql
2 |
3 | import (
4 | "fmt"
5 | "time"
6 |
7 | "github.com/henrylee2cn/goutil"
8 | "github.com/xiaoenai/tp-micro/v6/model/redis"
9 | "github.com/xiaoenai/tp-micro/v6/model/sqlx"
10 | "github.com/xiaoenai/tp-micro/v6/model/sqlx/reflectx"
11 | )
12 |
13 | // PreDB preset *DB
14 | type PreDB struct {
15 | *DB
16 | preFuncs map[string]func() error
17 | inited bool
18 | }
19 |
20 | // NewPreDB creates a unconnected *DB
21 | func NewPreDB() *PreDB {
22 | return &PreDB{
23 | DB: &DB{
24 | cacheableDBs: make(map[string]*CacheableDB),
25 | },
26 | preFuncs: make(map[string]func() error),
27 | }
28 | }
29 |
30 | // Init initialize *DB.
31 | func (p *PreDB) Init(dbConfig *Config, redisConfig *redis.Config) (err error) {
32 | var cache *redis.Client
33 | if !dbConfig.NoCache && redisConfig != nil {
34 | cache, err = redis.NewClient(redisConfig)
35 | if err != nil {
36 | return err
37 | }
38 | }
39 | return p.Init2(dbConfig, cache)
40 | }
41 |
42 | // Init2 initialize *DB.
43 | func (p *PreDB) Init2(dbConfig *Config, redisClient *redis.Client) (err error) {
44 | p.DB.DB, err = sqlx.Connect("mysql", dbConfig.Source())
45 | if err != nil {
46 | return err
47 | }
48 | p.DB.SetMaxOpenConns(dbConfig.MaxOpenConns)
49 | p.DB.SetMaxIdleConns(dbConfig.MaxIdleConns)
50 | p.DB.SetConnMaxLifetime(time.Duration(dbConfig.ConnMaxLifetime) * time.Second)
51 | // p.DB.MapperFunc(goutil.SnakeString)
52 | p.DB.Mapper = reflectx.NewMapperFunc("json", goutil.SnakeString)
53 | p.DB.dbConfig = dbConfig
54 | if !dbConfig.NoCache && redisClient != nil {
55 | p.DB.Cache = redisClient
56 | p.DB.redisConfig = redisClient.Config()
57 | }
58 |
59 | for _, preFunc := range p.preFuncs {
60 | if err = preFunc(); err != nil {
61 | return err
62 | }
63 | }
64 | p.inited = true
65 | return nil
66 | }
67 |
68 | // RegCacheableDB registers a cacheable table.
69 | func (p *PreDB) RegCacheableDB(ormStructPtr Cacheable, cacheExpiration time.Duration, initQuery string, args ...interface{}) (*CacheableDB, error) {
70 | if p.inited {
71 | if len(initQuery) > 0 {
72 | _, err := p.DB.Exec(initQuery, args...)
73 | if err != nil {
74 | return nil, err
75 | }
76 | }
77 | return p.DB.RegCacheableDB(ormStructPtr, cacheExpiration)
78 | }
79 |
80 | tableName := ormStructPtr.TableName()
81 | if _, ok := p.preFuncs[ormStructPtr.TableName()]; ok {
82 | return nil, fmt.Errorf("re-register cacheable table: %s", tableName)
83 | }
84 | var cacheableDB = new(CacheableDB)
85 | var preFunc = func() error {
86 | if len(initQuery) > 0 {
87 | _, err := p.DB.Exec(initQuery, args...)
88 | if err != nil {
89 | return err
90 | }
91 | }
92 | _cacheableDB, err := p.DB.RegCacheableDB(ormStructPtr, cacheExpiration)
93 | if err == nil {
94 | *cacheableDB = *_cacheableDB
95 | p.DB.cacheableDBs[tableName] = cacheableDB
96 | }
97 | return err
98 | }
99 | p.preFuncs[tableName] = preFunc
100 | return cacheableDB, nil
101 | }
102 |
--------------------------------------------------------------------------------
/helper/mod-html/render_test.go:
--------------------------------------------------------------------------------
1 | package html_test
2 |
3 | import (
4 | "testing"
5 | "time"
6 |
7 | html "github.com/xiaoenai/tp-micro/v6/helper/mod-html"
8 | )
9 |
10 | type meta struct{}
11 |
12 | func (m *meta) SetMeta(key, value string) {}
13 |
14 | func TestParseText(t *testing.T) {
15 | const (
16 | doc1 = `
17 |
18 |
19 | html test 1
20 |
21 |
22 |
23 | {{.}}
24 |
25 | `
26 | doc2 = `
27 |
28 |
29 | html test 2
30 |
31 |
32 |
33 | {{.}}
34 |
35 | `
36 | )
37 |
38 | err := html.Parse("a", doc1)
39 | if err != nil {
40 | t.Fatal(err)
41 | }
42 | err = html.Parse("b", doc2)
43 | if err != nil {
44 | t.Fatal(err)
45 | }
46 |
47 | b, stat := html.Render(new(meta), "a", "TestParse A!")
48 | t.Logf("body: %s, rerr: %v", b, stat)
49 | b, stat = html.Render(new(meta), "b", "TestParse B!")
50 | t.Logf("body: %s, rerr: %v", b, stat)
51 | }
52 |
53 | func TestParseFiles(t *testing.T) {
54 | err := html.ParseFiles("../mod-html/a_test.tpl", "../mod-html/b_test.tpl")
55 | if err != nil {
56 | t.Fatal(err)
57 | }
58 |
59 | b, stat := html.Render(new(meta), "a_test.tpl", "TestParseFiles A!")
60 | t.Logf("body: %s, rerr: %v", b, stat)
61 | b, stat = html.Render(new(meta), "b_test.tpl", "TestParseFiles B!")
62 | t.Logf("body: %s, rerr: %v", b, stat)
63 | }
64 |
65 | func TestParseGlob(t *testing.T) {
66 | err := html.ParseGlob("../mod-html/*.tpl")
67 | if err != nil {
68 | t.Fatal(err)
69 | }
70 |
71 | b, stat := html.Render(new(meta), "a_test.tpl", "TestParseGlob A!")
72 | t.Logf("body: %s, rerr: %v", b, stat)
73 | b, stat = html.Render(new(meta), "b_test.tpl", "TestParseGlob B!")
74 | t.Logf("body: %s, rerr: %v", b, stat)
75 | }
76 |
77 | func TestDelims(t *testing.T) {
78 | const (
79 | doc = `
80 |
81 |
82 | html test 1
83 |
84 |
85 |
86 | {{{.}}}
87 |
88 | `
89 | )
90 |
91 | html.Delims("{{{", "}}}")
92 | err := html.Parse("doc", doc)
93 | if err != nil {
94 | t.Fatal(err)
95 | }
96 | b, stat := html.Render(new(meta), "doc", "TestDelims!")
97 | t.Logf("body: %s, rerr: %v", b, stat)
98 | }
99 |
100 | func TestGoTimingRefresh(t *testing.T) {
101 | err := html.ParseFiles("../mod-html/a_test.tpl")
102 | if err != nil {
103 | t.Fatal(err)
104 | }
105 | err = html.ParseGlob("../mod-html/*.tpl")
106 | if err != nil {
107 | t.Fatal(err)
108 | }
109 |
110 | b, stat := html.Render(new(meta), "a_test.tpl", "TestGoTimingRefresh 1!")
111 | t.Logf("test1: body: %s, rerr: %v", b, stat)
112 |
113 | html.GoTimingRefresh(time.Second * 5)
114 | time.Sleep(time.Second * 15)
115 |
116 | b, stat = html.Render(new(meta), "a_test.tpl", "TestGoTimingRefresh 2!")
117 | t.Logf("test2: body: %s, rerr: %v", b, stat)
118 | }
119 |
--------------------------------------------------------------------------------
/gateway/config.go:
--------------------------------------------------------------------------------
1 | // Copyright 2018 github.com/xiaoenai. All Rights Reserved.
2 | //
3 | // Licensed under the Apache License, Version 2.0 (the "License");
4 | // you may not use this file except in compliance with the License.
5 | // You may obtain a copy of the License at
6 | //
7 | // http://www.apache.org/licenses/LICENSE-2.0
8 | //
9 | // Unless required by applicable law or agreed to in writing, software
10 | // distributed under the License is distributed on an "AS IS" BASIS,
11 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 | // See the License for the specific language governing permissions and
13 | // limitations under the License.
14 |
15 | package gateway
16 |
17 | import (
18 | "time"
19 |
20 | "github.com/henrylee2cn/cfgo"
21 | micro "github.com/xiaoenai/tp-micro/v6"
22 | short "github.com/xiaoenai/tp-micro/v6/gateway/logic/http"
23 | "github.com/xiaoenai/tp-micro/v6/model/etcd"
24 | )
25 |
26 | // Config app config
27 | type Config struct {
28 | EnableHttp bool `yaml:"enable_http"`
29 | EnableSocket bool `yaml:"enable_socket"`
30 | EnableWebSocket bool `yaml:"enable_web_socket"`
31 | OuterHttpServer short.HttpSrvConfig `yaml:"outer_http_server"`
32 | OuterSocketServer micro.SrvConfig `yaml:"outer_socket_server"`
33 | InnerSocketServer micro.SrvConfig `yaml:"inner_socket_server"`
34 | InnerSocketClient micro.CliConfig `yaml:"inner_socket_client"`
35 | WebSocketServer micro.SrvConfig `yaml:"web_socket_server"`
36 | Etcd etcd.EasyConfig `yaml:"etcd"`
37 | }
38 |
39 | // NewConfig creates a default config.
40 | func NewConfig() *Config {
41 | return &Config{
42 | EnableHttp: true,
43 | EnableSocket: true,
44 | EnableWebSocket: true,
45 | OuterHttpServer: short.HttpSrvConfig{
46 | ListenAddress: "0.0.0.0:5000",
47 | AllowCross: false,
48 | },
49 | OuterSocketServer: micro.SrvConfig{
50 | ListenAddress: "0.0.0.0:5020",
51 | EnableHeartbeat: true,
52 | PrintDetail: true,
53 | CountTime: true,
54 | SlowCometDuration: time.Millisecond * 500,
55 | },
56 | InnerSocketServer: micro.SrvConfig{
57 | ListenAddress: "0.0.0.0:5030",
58 | EnableHeartbeat: true,
59 | PrintDetail: true,
60 | CountTime: true,
61 | SlowCometDuration: time.Millisecond * 500,
62 | },
63 | WebSocketServer: micro.SrvConfig{
64 | ListenAddress: "0.0.0.0:5040",
65 | EnableHeartbeat: true,
66 | PrintDetail: true,
67 | CountTime: true,
68 | SlowCometDuration: time.Millisecond * 500,
69 | },
70 | }
71 | }
72 |
73 | // Reload Bi-directionally synchronizes config between YAML file and memory.
74 | func (c *Config) Reload(bind cfgo.BindFunc) error {
75 | err := bind()
76 | if err == nil {
77 | c.OuterHttpServer.OuterIpPort()
78 | }
79 | c.OuterHttpServer.PrintDetail = c.OuterSocketServer.PrintDetail
80 | c.OuterHttpServer.CountTime = c.OuterSocketServer.CountTime
81 | c.OuterHttpServer.SlowCometDuration = c.OuterSocketServer.SlowCometDuration
82 | return err
83 | }
84 |
85 | // check the config
86 | func (c *Config) check() error {
87 | return nil
88 | }
89 |
--------------------------------------------------------------------------------
/model/sqlx/types/types_test.go:
--------------------------------------------------------------------------------
1 | package types
2 |
3 | import "testing"
4 |
5 | func TestGzipText(t *testing.T) {
6 | g := GzippedText("Hello, world")
7 | v, err := g.Value()
8 | if err != nil {
9 | t.Errorf("Was not expecting an error")
10 | }
11 | err = (&g).Scan(v)
12 | if err != nil {
13 | t.Errorf("Was not expecting an error")
14 | }
15 | if string(g) != "Hello, world" {
16 | t.Errorf("Was expecting the string we sent in (Hello World), got %s", string(g))
17 | }
18 | }
19 |
20 | func TestJSONText(t *testing.T) {
21 | j := JSONText(`{"foo": 1, "bar": 2}`)
22 | v, err := j.Value()
23 | if err != nil {
24 | t.Errorf("Was not expecting an error")
25 | }
26 | err = (&j).Scan(v)
27 | if err != nil {
28 | t.Errorf("Was not expecting an error")
29 | }
30 | m := map[string]interface{}{}
31 | j.Unmarshal(&m)
32 |
33 | if m["foo"].(float64) != 1 || m["bar"].(float64) != 2 {
34 | t.Errorf("Expected valid json but got some garbage instead? %#v", m)
35 | }
36 |
37 | j = JSONText(`{"foo": 1, invalid, false}`)
38 | v, err = j.Value()
39 | if err == nil {
40 | t.Errorf("Was expecting invalid json to fail!")
41 | }
42 |
43 | j = JSONText("")
44 | v, err = j.Value()
45 | if err != nil {
46 | t.Errorf("Was not expecting an error")
47 | }
48 |
49 | err = (&j).Scan(v)
50 | if err != nil {
51 | t.Errorf("Was not expecting an error")
52 | }
53 |
54 | j = JSONText(nil)
55 | v, err = j.Value()
56 | if err != nil {
57 | t.Errorf("Was not expecting an error")
58 | }
59 |
60 | err = (&j).Scan(v)
61 | if err != nil {
62 | t.Errorf("Was not expecting an error")
63 | }
64 | }
65 |
66 | func TestNullJSONText(t *testing.T) {
67 | j := NullJSONText{}
68 | err := j.Scan(`{"foo": 1, "bar": 2}`)
69 | if err != nil {
70 | t.Errorf("Was not expecting an error")
71 | }
72 | v, err := j.Value()
73 | if err != nil {
74 | t.Errorf("Was not expecting an error")
75 | }
76 | err = (&j).Scan(v)
77 | if err != nil {
78 | t.Errorf("Was not expecting an error")
79 | }
80 | m := map[string]interface{}{}
81 | j.Unmarshal(&m)
82 |
83 | if m["foo"].(float64) != 1 || m["bar"].(float64) != 2 {
84 | t.Errorf("Expected valid json but got some garbage instead? %#v", m)
85 | }
86 |
87 | j = NullJSONText{}
88 | err = j.Scan(nil)
89 | if err != nil {
90 | t.Errorf("Was not expecting an error")
91 | }
92 | if j.Valid != false {
93 | t.Errorf("Expected valid to be false, but got true")
94 | }
95 | }
96 |
97 | func TestBitBool(t *testing.T) {
98 | // Test true value
99 | var b BitBool = true
100 |
101 | v, err := b.Value()
102 | if err != nil {
103 | t.Errorf("Cannot return error")
104 | }
105 | err = (&b).Scan(v)
106 | if err != nil {
107 | t.Errorf("Was not expecting an error")
108 | }
109 | if !b {
110 | t.Errorf("Was expecting the bool we sent in (true), got %v", b)
111 | }
112 |
113 | // Test false value
114 | b = false
115 |
116 | v, err = b.Value()
117 | if err != nil {
118 | t.Errorf("Cannot return error")
119 | }
120 | err = (&b).Scan(v)
121 | if err != nil {
122 | t.Errorf("Was not expecting an error")
123 | }
124 | if b {
125 | t.Errorf("Was expecting the bool we sent in (false), got %v", b)
126 | }
127 | }
128 |
--------------------------------------------------------------------------------
/model/mysql/db_test.go:
--------------------------------------------------------------------------------
1 | package mysql_test
2 |
3 | import (
4 | "encoding/json"
5 | "testing"
6 | "time"
7 |
8 | "github.com/henrylee2cn/goutil"
9 | "github.com/xiaoenai/tp-micro/v6/model/mysql"
10 | "github.com/xiaoenai/tp-micro/v6/model/redis"
11 | "github.com/xiaoenai/tp-micro/v6/model/sqlx"
12 | "github.com/xiaoenai/tp-micro/v6/model/sqlx/reflectx"
13 | )
14 |
15 | type testTable struct {
16 | TestId int64
17 | TestContent string
18 | Deleted bool `json:"test_deleted"`
19 | }
20 |
21 | func (t *testTable) TableName() string {
22 | return "dbtest"
23 | }
24 |
25 | func TestNamed(t *testing.T) {
26 | db := new(sqlx.DB)
27 | db.Mapper = reflectx.NewMapperFunc("json", goutil.SnakeString)
28 | p := &testTable{
29 | TestId: 123,
30 | TestContent: "ctn",
31 | Deleted: true,
32 | }
33 | whereCond, values, err := db.BindNamed("test_id=:test_id AND test_content=:test_content OR test_deleted=1", p)
34 | if err != nil {
35 | t.Fatal(err)
36 | }
37 | t.Logf("whereCond:%s", whereCond)
38 | t.Logf("values:%v", values)
39 | // Output:
40 | // test_id=? AND test_content=? OR test_deleted=1
41 | // values:[123 ctn]
42 | }
43 |
44 | func TestCacheDb(t *testing.T) {
45 | dbConf, err := mysql.ReadConfig("test_db")
46 | if err != nil {
47 | t.Fatal(err)
48 | }
49 | dbConf.Database = "test"
50 | redisConf, err := redis.ReadConfig("test_redis")
51 | if err != nil {
52 | t.Fatal(err)
53 | }
54 | db, err := mysql.Connect(dbConf, redisConf)
55 | if err != nil {
56 | t.Fatal(err)
57 | }
58 | _, err = db.Exec("CREATE TABLE IF NOT EXISTS `dbtest` (`test_id` INT(10) AUTO_INCREMENT, `test_content` VARCHAR(20), `test_deleted` TINYINT(2), PRIMARY KEY(`test_id`)) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='测试表'")
59 | if err != nil {
60 | t.Fatal(err)
61 | }
62 | c, err := db.RegCacheableDB(new(testTable), time.Second)
63 | if err != nil {
64 | t.Fatal(err)
65 | }
66 | obj := &testTable{
67 | TestId: 1,
68 | TestContent: "abc",
69 | Deleted: false,
70 | }
71 | _, err = c.NamedExec("INSERT INTO dbtest (test_id,test_content,test_deleted)VALUES(:test_id,:test_content,:test_deleted) ON DUPLICATE KEY UPDATE test_id=:test_id", obj)
72 | if err != nil {
73 | t.Fatal(err)
74 | }
75 |
76 | // query and cache
77 | dest := &testTable{TestId: 1}
78 | err = c.CacheGet(dest)
79 | if err != nil {
80 | t.Fatal(err)
81 | }
82 | t.Logf("first:%#v", dest)
83 |
84 | // verify the cache
85 | cacheKey, _, err := c.CreateCacheKey(dest)
86 | t.Logf("cacheKey:%#v", cacheKey)
87 | key := cacheKey.Key
88 | if err != nil {
89 | t.Fatal(err)
90 | }
91 | b, err := c.Cache.Get(key).Bytes()
92 | if err != nil {
93 | t.Fatal(err)
94 | }
95 | var v1 = new(testTable)
96 | err = json.Unmarshal(b, v1)
97 | if err != nil {
98 | t.Fatal(err)
99 | }
100 | t.Logf("cache of before expiring: %+v", v1)
101 |
102 | time.Sleep(2 * time.Second)
103 |
104 | b, err = c.Cache.Get(key).Bytes()
105 | if err == nil {
106 | var v2 = new(testTable)
107 | err = json.Unmarshal(b, v2)
108 | if err != nil {
109 | t.Fatal(err)
110 | }
111 | t.Fatalf("expired but not deleted: %#v", v2)
112 | }
113 | t.Logf("expired cache error: %v", err)
114 | }
115 |
--------------------------------------------------------------------------------
/gateway/logic/websocket/api.go:
--------------------------------------------------------------------------------
1 | package websocket
2 |
3 | import (
4 | "strings"
5 | "sync"
6 | _ "unsafe"
7 |
8 | "github.com/henrylee2cn/erpc/v6"
9 | "github.com/xiaoenai/tp-micro/v6/gateway/logic"
10 | "github.com/xiaoenai/tp-micro/v6/gateway/types"
11 | )
12 |
13 | // Gw long connection controller.
14 | type Gw struct {
15 | erpc.CallCtx
16 | }
17 |
18 | // totalConn returns the long connections total.
19 | //go:linkname totalConn github.com/xiaoenai/tp-micro/gateway.TotalConn
20 | //go:nosplit
21 | func wsTotalConn() int32 {
22 | if outerPeer == nil {
23 | return 0
24 | }
25 | return int32(outerPeer.CountSession())
26 | }
27 |
28 | // WsTotal returns the long connections total.
29 | func (g *Gw) WsTotal(*types.WsTotalArgs) (*types.WsTotalReply, *erpc.Status) {
30 | return &types.WsTotalReply{ConnTotal: wsTotalConn()}, nil
31 | }
32 |
33 | // innerPush pushes the message to the specified user.
34 | func innerPush(uid string, uri string, args interface{}, bodyCodec byte) *erpc.Status {
35 | sess, stat := logic.WebSocketHooks().GetSession(outerPeer, uid)
36 | if stat != nil {
37 | return stat
38 | }
39 | return sess.Push(uri, args, erpc.WithBodyCodec(bodyCodec))
40 | }
41 |
42 | var wsPushReply = new(types.WsPushReply)
43 |
44 | // WsPush pushes message to the specified user.
45 | func (g *Gw) WsPush(args *types.WsPushArgs) (*types.WsPushReply, *erpc.Status) {
46 | stat := innerPush(args.SessionId, args.Uri, args.Body, byte(args.BodyCodec))
47 | if stat != nil {
48 | return nil, stat
49 | }
50 | return wsPushReply, nil
51 | }
52 |
53 | // WsMpush multi-push messages to the specified users.
54 | func (g *Gw) WsMpush(args *types.WsMpushArgs) (*types.WsMpushReply, *erpc.Status) {
55 | var (
56 | wg sync.WaitGroup
57 | sep = "?"
58 | failureSessionIds = make([]string, 0, len(args.Target))
59 | lock sync.Mutex
60 | body = args.Body
61 | bodyCodec = byte(args.BodyCodec)
62 | )
63 | if strings.Contains(args.Uri, "?") {
64 | sep = "&"
65 | }
66 | wg.Add(len(args.Target))
67 | for _, t := range args.Target {
68 | var uri string
69 | if t.AdditionalQuery != "" {
70 | uri = args.Uri + sep + t.AdditionalQuery
71 | } else {
72 | uri = args.Uri
73 | }
74 | sessId := t.SessionId
75 | erpc.TryGo(func() {
76 | defer wg.Done()
77 | stat := innerPush(sessId, uri, body, bodyCodec)
78 | if stat != nil {
79 | lock.Lock()
80 | failureSessionIds = append(failureSessionIds, sessId)
81 | lock.Unlock()
82 | erpc.Tracef("SocketMpush: %s", stat.String())
83 | }
84 | })
85 | }
86 | wg.Wait()
87 | return &types.WsMpushReply{
88 | FailureSessionIds: failureSessionIds,
89 | }, nil
90 | }
91 |
92 | // Kick kicks the uid offline.
93 | func Kick(uid string) (existed bool, err error) {
94 | sess, existed := outerPeer.GetSession(uid)
95 | if existed {
96 | err = sess.Close()
97 | }
98 | return existed, err
99 | }
100 |
101 | // SocketKick kicks the uid offline.
102 | func (g *Gw) WsKick(args *types.SocketKickArgs) (*types.SocketKickReply, *erpc.Status) {
103 | existed, _ := Kick(args.SessionId)
104 | return &types.SocketKickReply{
105 | Existed: existed,
106 | }, nil
107 | }
108 |
--------------------------------------------------------------------------------
/examples/custom/browser.go:
--------------------------------------------------------------------------------
1 | package main
2 |
3 | import (
4 | "log"
5 | "net/http"
6 | "os"
7 | "os/exec"
8 | "runtime"
9 | "time"
10 | )
11 |
12 | func main() {
13 | go http.ListenAndServe(":8080", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
14 | w.Write([]byte(html))
15 | }))
16 | var cmd *exec.Cmd
17 | switch runtime.GOOS {
18 | case "windows":
19 | cmd = exec.Command("cmd", "/c", "start", "http://localhost:8080")
20 | case "darwin":
21 | cmd = exec.Command("open", "http://localhost:8080")
22 | }
23 | if cmd != nil {
24 | go func() {
25 | log.Println("[browser] Open the default browser after two seconds...")
26 | time.Sleep(time.Second * 2)
27 | cmd.Stdout = os.Stdout
28 | cmd.Stderr = os.Stderr
29 | cmd.Run()
30 | }()
31 | }
32 | select {}
33 | }
34 |
35 | const html = `
36 |
37 |
38 | /math/divide
39 |
40 |
41 |
42 |
46 |
47 |
48 |
49 |
50 | Go to Home Page
51 | Test Redirect to Home Page
52 |
105 |
106 | `
107 |
--------------------------------------------------------------------------------
/examples/simple/browser.go:
--------------------------------------------------------------------------------
1 | package main
2 |
3 | import (
4 | "log"
5 | "net/http"
6 | "os"
7 | "os/exec"
8 | "runtime"
9 | "time"
10 | )
11 |
12 | //go:generate go build $GOFILE
13 |
14 | func main() {
15 | go http.ListenAndServe(":8080", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
16 | w.Write([]byte(html))
17 | }))
18 | var cmd *exec.Cmd
19 | switch runtime.GOOS {
20 | case "windows":
21 | cmd = exec.Command("cmd", "/c", "start", "http://localhost:8080")
22 | case "darwin":
23 | cmd = exec.Command("open", "http://localhost:8080")
24 | }
25 | if cmd != nil {
26 | go func() {
27 | log.Println("[browser] Open the default browser after two seconds...")
28 | time.Sleep(time.Second * 2)
29 | cmd.Stdout = os.Stdout
30 | cmd.Stderr = os.Stderr
31 | cmd.Run()
32 | }()
33 | }
34 | select {}
35 | }
36 |
37 | const html = `
38 |
39 |
40 | /math/divide
41 |
42 |
43 |
44 |
48 |
49 |
50 |
51 |
52 | Go to Home Page
53 | Test Redirect to Home Page
54 |
107 |
108 | `
109 |
--------------------------------------------------------------------------------
/examples/custom/config/config.yaml:
--------------------------------------------------------------------------------
1 | cluster_client:
2 | network: tcp
3 | local_ip: 0.0.0.0
4 | tls_cert_file: ""
5 | tls_key_file: ""
6 | default_session_age: 0s
7 | default_context_age: 0s
8 | default_dial_timeout: 0s
9 | failover: 0
10 | slow_comet_duration: 0s
11 | default_body_codec: ""
12 | print_detail: false
13 | count_time: false
14 | heartbeat_second: 0
15 | circuit_breaker:
16 | enable: false
17 | error_percentage: 50
18 | break_duration: 5s
19 |
20 | etcd:
21 | endpoints:
22 | - http://127.0.0.1:2379
23 | dial_timeout: 15s
24 | username: ""
25 | password: ""
26 |
27 | gateway:
28 | gw:
29 | enable_http: true
30 | enable_socket: true
31 | outer_http_server:
32 | listen_address: 0.0.0.0:5000
33 | outer_host: ""
34 | tls_cert_file: ""
35 | tls_key_file: ""
36 | allow_cross: true
37 | outer_socket_server:
38 | network: ""
39 | listen_address: 0.0.0.0:5020
40 | tls_cert_file: ""
41 | tls_key_file: ""
42 | default_session_age: 0s
43 | default_context_age: 0s
44 | slow_comet_duration: 0s
45 | default_body_codec: ""
46 | print_detail: true
47 | count_time: true
48 | enable_heartbeat: true
49 | inner_socket_server:
50 | network: ""
51 | listen_address: 0.0.0.0:5030
52 | tls_cert_file: ""
53 | tls_key_file: ""
54 | default_session_age: 0s
55 | default_context_age: 0s
56 | slow_comet_duration: 0s
57 | default_body_codec: ""
58 | print_detail: true
59 | count_time: true
60 | enable_heartbeat: true
61 | gray_socket_client:
62 | network: ""
63 | local_ip: ""
64 | tls_cert_file: ""
65 | tls_key_file: ""
66 | default_session_age: 0s
67 | default_context_age: 0s
68 | default_dial_timeout: 0s
69 | failover: 3
70 | slow_comet_duration: 0s
71 | default_body_codec: ""
72 | print_detail: false
73 | count_time: false
74 | heartbeat_second: 60
75 | circuit_breaker:
76 | enable: false
77 | error_percentage: 0
78 | break_duration: 0s
79 | gray_etcd:
80 | endpoints:
81 | - http://127.0.0.1:2379
82 | dial_timeout: 0s
83 | username: ""
84 | password: ""
85 | redis:
86 | deploy_type: single
87 | for_single:
88 | addr: 127.0.0.1:6379
89 | for_cluster:
90 | addrs: []
91 | pool_size_per_node: 0
92 | idle_timeout: 0
93 | mysql:
94 | database: test
95 | username: root
96 | password: ""
97 | host: 127.0.0.1
98 | port: 3306
99 | max_idle_conns: 0
100 | max_open_conns: 0
101 | conn_max_lifetime: 0
102 | no_cache: false
103 |
104 | server:
105 | etcd:
106 | dial_timeout: 0s
107 | endpoints:
108 | - http://127.0.0.1:2379
109 | password: ""
110 | username: ""
111 | redis:
112 | deploy_type: single
113 | for_cluster:
114 | addrs: []
115 | for_single:
116 | addr: 127.0.0.1:6379
117 | idle_timeout: 0
118 | pool_size_per_node: 0
119 | srv:
120 | count_time: false
121 | default_body_codec: ""
122 | default_context_age: 0s
123 | default_session_age: 0s
124 | enable_heartbeat: true
125 | listen_address: :0
126 | network: ""
127 | print_detail: false
128 | slow_comet_duration: 0s
129 | tls_cert_file: ""
130 | tls_key_file: ""
131 |
--------------------------------------------------------------------------------
/micro/create/structtag/LICENSE:
--------------------------------------------------------------------------------
1 | Copyright (c) 2017, Fatih Arslan
2 | All rights reserved.
3 |
4 | Redistribution and use in source and binary forms, with or without
5 | modification, are permitted provided that the following conditions are met:
6 |
7 | * Redistributions of source code must retain the above copyright notice, this
8 | list of conditions and the following disclaimer.
9 |
10 | * Redistributions in binary form must reproduce the above copyright notice,
11 | this list of conditions and the following disclaimer in the documentation
12 | and/or other materials provided with the distribution.
13 |
14 | * Neither the name of structtag nor the names of its
15 | contributors may be used to endorse or promote products derived from
16 | this software without specific prior written permission.
17 |
18 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
19 | AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20 | IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
21 | DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
22 | FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
23 | DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
24 | SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
25 | CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
26 | OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
27 | OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 |
29 | This software includes some portions from Go. Go is used under the terms of the
30 | BSD like license.
31 |
32 | Copyright (c) 2012 The Go Authors. All rights reserved.
33 |
34 | Redistribution and use in source and binary forms, with or without
35 | modification, are permitted provided that the following conditions are
36 | met:
37 |
38 | * Redistributions of source code must retain the above copyright
39 | notice, this list of conditions and the following disclaimer.
40 | * Redistributions in binary form must reproduce the above
41 | copyright notice, this list of conditions and the following disclaimer
42 | in the documentation and/or other materials provided with the
43 | distribution.
44 | * Neither the name of Google Inc. nor the names of its
45 | contributors may be used to endorse or promote products derived from
46 | this software without specific prior written permission.
47 |
48 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
49 | "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
50 | LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
51 | A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
52 | OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
53 | SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
54 | LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
55 | DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
56 | THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
57 | (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
58 | OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
59 |
60 | The Go gopher was designed by Renee French. http://reneefrench.blogspot.com/ The design is licensed under the Creative Commons 3.0 Attributions license. Read this article for more details: https://blog.golang.org/gopher
61 |
--------------------------------------------------------------------------------
/gateway/logic/http/server.go:
--------------------------------------------------------------------------------
1 | // Copyright 2018 github.com/xiaoenai. All Rights Reserved.
2 | //
3 | // Licensed under the Apache License, Version 2.0 (the "License");
4 | // you may not use this file except in compliance with the License.
5 | // You may obtain a copy of the License at
6 | //
7 | // http://www.apache.org/licenses/LICENSE-2.0
8 | //
9 | // Unless required by applicable law or agreed to in writing, software
10 | // distributed under the License is distributed on an "AS IS" BASIS,
11 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 | // See the License for the specific language governing permissions and
13 | // limitations under the License.
14 |
15 | package http
16 |
17 | import (
18 | "crypto/tls"
19 | "fmt"
20 | "net"
21 | "net/http"
22 | "time"
23 |
24 | "github.com/henrylee2cn/erpc/v6"
25 | "github.com/valyala/fasthttp"
26 | micro "github.com/xiaoenai/tp-micro/v6"
27 | "github.com/xiaoenai/tp-micro/v6/gateway/logic"
28 | )
29 |
30 | // HttpSrvConfig config of HTTP server
31 | type HttpSrvConfig struct {
32 | ListenAddress string `yaml:"listen_address"`
33 | OuterHost string `yaml:"outer_host"`
34 | TlsCertFile string `yaml:"tls_cert_file"`
35 | TlsKeyFile string `yaml:"tls_key_file"`
36 | AllowCross bool `yaml:"allow_cross"`
37 | PrintDetail bool `yaml:"-"`
38 | CountTime bool `yaml:"-"`
39 | SlowCometDuration time.Duration `yaml:"-"`
40 | }
41 |
42 | // ListenPort returns the listened port, such as '8080'.
43 | func (h *HttpSrvConfig) ListenPort() string {
44 | _, port, err := net.SplitHostPort(h.ListenAddress)
45 | if err != nil {
46 | erpc.Fatalf("%v", err)
47 | }
48 | return port
49 | }
50 |
51 | // InnerIpPort returns the service's intranet address, such as '192.168.1.120:8080'.
52 | func (h *HttpSrvConfig) InnerIpPort() string {
53 | hostPort, err := micro.InnerIpPort(h.ListenPort())
54 | if err != nil {
55 | erpc.Fatalf("%v", err)
56 | }
57 | return hostPort
58 | }
59 |
60 | // OuterIpPort returns the service's extranet address, such as '113.116.141.121:8080'.
61 | func (h *HttpSrvConfig) OuterIpPort() string {
62 | if len(h.OuterHost) == 0 {
63 | h.OuterHost, _ = micro.OuterIpPort(h.ListenPort())
64 | }
65 | return h.OuterHost
66 | }
67 |
68 | // Serve starts HTTP gateway service.
69 | func Serve(srvCfg HttpSrvConfig) {
70 | printDetail = srvCfg.PrintDetail
71 | countTime = srvCfg.CountTime
72 | if srvCfg.SlowCometDuration > 0 {
73 | slowCometDuration = srvCfg.SlowCometDuration
74 | }
75 | gwHostsUri = "/gw/" + logic.ApiVersion() + "/hosts"
76 | var tlsConfig *tls.Config
77 | addr, err := erpc.NewFakeAddr2("tcp", srvCfg.ListenAddress)
78 | if err != nil {
79 | erpc.Fatalf("%v", err)
80 | }
81 | lis, err := erpc.NewInheritedListener(addr, tlsConfig)
82 | if err != nil {
83 | erpc.Fatalf("%v", err)
84 | }
85 |
86 | allowCross = srvCfg.AllowCross
87 |
88 | var network = "http"
89 | if tlsConfig != nil {
90 | network = "https"
91 | }
92 | erpc.Printf("register HTTP handler: %s", gwHostsUri)
93 | erpc.Printf("listen ok (network:%s, addr:%s)", network, lis.Addr())
94 |
95 | err = (&fasthttp.Server{
96 | Name: fmt.Sprintf("micro-gateway-%s", logic.ApiVersion()),
97 | Handler: handler,
98 | }).Serve(lis)
99 |
100 | if err != nil && err != http.ErrServerClosed {
101 | erpc.Fatalf("%v", err)
102 | }
103 | }
104 |
--------------------------------------------------------------------------------
/helper/mod-html/README.md:
--------------------------------------------------------------------------------
1 | ## html
2 |
3 | HTML render for http client.
4 |
5 | ### Usage
6 |
7 | `html "github.com/xiaoenai/tp-micro/v6/helper/mod-html"`
8 |
9 | #### Test
10 |
11 | ```go
12 | package html_test
13 |
14 | import (
15 | "testing"
16 | "time"
17 |
18 | html "github.com/xiaoenai/tp-micro/v6/helper/mod-html"
19 | )
20 |
21 | type meta struct{}
22 |
23 | func (m *meta) SetMeta(key, value string) {}
24 |
25 | func TestParseText(t *testing.T) {
26 | const (
27 | doc1 = `
28 |
29 |
30 | html test 1
31 |
32 |
33 |
34 | {{.}}
35 |
36 | `
37 | doc2 = `
38 |
39 |
40 | html test 2
41 |
42 |
43 |
44 | {{.}}
45 |
46 | `
47 | )
48 |
49 | err := html.Parse("a", doc1)
50 | if err != nil {
51 | t.Fatal(err)
52 | }
53 | err = html.Parse("b", doc2)
54 | if err != nil {
55 | t.Fatal(err)
56 | }
57 |
58 | b, rerr := html.Render(new(meta), "a", "TestParse A!")
59 | t.Logf("body: %s, rerr: %v", b, rerr)
60 | b, rerr = html.Render(new(meta), "b", "TestParse B!")
61 | t.Logf("body: %s, rerr: %v", b, rerr)
62 | }
63 |
64 | func TestParseFiles(t *testing.T) {
65 | err := html.ParseFiles("../mod-html/a_test.tpl", "../mod-html/b_test.tpl")
66 | if err != nil {
67 | t.Fatal(err)
68 | }
69 |
70 | b, rerr := html.Render(new(meta), "a_test.tpl", "TestParseFiles A!")
71 | t.Logf("body: %s, rerr: %v", b, rerr)
72 | b, rerr = html.Render(new(meta), "b_test.tpl", "TestParseFiles B!")
73 | t.Logf("body: %s, rerr: %v", b, rerr)
74 | }
75 |
76 | func TestParseGlob(t *testing.T) {
77 | err := html.ParseGlob("../mod-html/*.tpl")
78 | if err != nil {
79 | t.Fatal(err)
80 | }
81 |
82 | b, rerr := html.Render(new(meta), "a_test.tpl", "TestParseGlob A!")
83 | t.Logf("body: %s, rerr: %v", b, rerr)
84 | b, rerr = html.Render(new(meta), "b_test.tpl", "TestParseGlob B!")
85 | t.Logf("body: %s, rerr: %v", b, rerr)
86 | }
87 |
88 | func TestDelims(t *testing.T) {
89 | const (
90 | doc = `
91 |
92 |
93 | html test 1
94 |
95 |
96 |
97 | {{{.}}}
98 |
99 | `
100 | )
101 |
102 | html.Delims("{{{", "}}}")
103 | err := html.Parse("doc", doc)
104 | if err != nil {
105 | t.Fatal(err)
106 | }
107 | b, rerr := html.Render(new(meta), "doc", "TestDelims!")
108 | t.Logf("body: %s, rerr: %v", b, rerr)
109 | }
110 |
111 | func TestGoTimingRefresh(t *testing.T) {
112 | err := html.ParseFiles("../mod-html/a_test.tpl")
113 | if err != nil {
114 | t.Fatal(err)
115 | }
116 | err = html.ParseGlob("../mod-html/*.tpl")
117 | if err != nil {
118 | t.Fatal(err)
119 | }
120 |
121 | b, rerr := html.Render(new(meta), "a_test.tpl", "TestGoTimingRefresh 1!")
122 | t.Logf("test1: body: %s, rerr: %v", b, rerr)
123 |
124 | html.GoTimingRefresh(time.Second * 5)
125 | time.Sleep(time.Second * 15)
126 |
127 | b, rerr = html.Render(new(meta), "a_test.tpl", "TestGoTimingRefresh 2!")
128 | t.Logf("test2: body: %s, rerr: %v", b, rerr)
129 | }
130 | ```
131 |
132 | test command:
133 |
134 | ```sh
135 | go test -v -run=TestParseText
136 | go test -v -run=TestParseFiles
137 | go test -v -run=TestParseGlob
138 | go test -v -run=TestDelims
139 | go test -v -run=TestGoTimingRefresh
140 | ```
141 |
--------------------------------------------------------------------------------
/gateway/logic/socket/api.go:
--------------------------------------------------------------------------------
1 | package socket
2 |
3 | import (
4 | "strings"
5 | "sync"
6 | _ "unsafe"
7 |
8 | "github.com/henrylee2cn/erpc/v6"
9 | "github.com/xiaoenai/tp-micro/v6/gateway/logic"
10 | "github.com/xiaoenai/tp-micro/v6/gateway/logic/hosts"
11 | "github.com/xiaoenai/tp-micro/v6/gateway/types"
12 | )
13 |
14 | // gw long connection controller.
15 | type gw struct {
16 | erpc.CallCtx
17 | }
18 |
19 | // Hosts returns the gateway seriver hosts.
20 | func (g *gw) Hosts(*struct{}) (*types.GwHosts, *erpc.Status) {
21 | return hosts.GwHosts(), nil
22 | }
23 |
24 | // totalConn returns the long connections total.
25 | //go:linkname totalConn github.com/xiaoenai/tp-micro/gateway.TotalConn
26 | //go:nosplit
27 | func totalConn() int32 {
28 | if outerPeer == nil {
29 | return 0
30 | }
31 | return int32(outerPeer.CountSession())
32 | }
33 |
34 | // SocketTotal returns the long connections total.
35 | func (g *gw) SocketTotal(*types.SocketTotalArgs) (*types.SocketTotalReply, *erpc.Status) {
36 | return &types.SocketTotalReply{ConnTotal: totalConn()}, nil
37 | }
38 |
39 | // innerPush pushes the message to the specified user.
40 | func innerPush(uid string, uri string, args interface{}, bodyCodec byte) *erpc.Status {
41 | sess, stat := logic.SocketHooks().GetSession(outerPeer, uid)
42 | if stat != nil {
43 | return stat
44 | }
45 | return sess.Push(uri, args, erpc.WithBodyCodec(bodyCodec))
46 | }
47 |
48 | var socketPushReply = new(types.SocketPushReply)
49 |
50 | // SocketPush pushes message to the specified user.
51 | func (g *gw) SocketPush(args *types.SocketPushArgs) (*types.SocketPushReply, *erpc.Status) {
52 | stat := innerPush(args.SessionId, args.Uri, args.Body, byte(args.BodyCodec))
53 | if stat != nil {
54 | return nil, stat
55 | }
56 | return socketPushReply, nil
57 | }
58 |
59 | // SocketMpush multi-push messages to the specified users.
60 | func (g *gw) SocketMpush(args *types.SocketMpushArgs) (*types.SocketMpushReply, *erpc.Status) {
61 | var (
62 | wg sync.WaitGroup
63 | sep = "?"
64 | failureSessionIds = make([]string, 0, len(args.Target))
65 | lock sync.Mutex
66 | body = args.Body
67 | bodyCodec = byte(args.BodyCodec)
68 | )
69 | if strings.Contains(args.Uri, "?") {
70 | sep = "&"
71 | }
72 | wg.Add(len(args.Target))
73 | for _, t := range args.Target {
74 | var uri string
75 | if t.AdditionalQuery != "" {
76 | uri = args.Uri + sep + t.AdditionalQuery
77 | } else {
78 | uri = args.Uri
79 | }
80 | sessId := t.SessionId
81 | erpc.TryGo(func() {
82 | defer wg.Done()
83 | stat := innerPush(sessId, uri, body, bodyCodec)
84 | if stat != nil {
85 | lock.Lock()
86 | failureSessionIds = append(failureSessionIds, sessId)
87 | lock.Unlock()
88 | erpc.Tracef("SocketMpush: %s", stat.String())
89 | }
90 | })
91 | }
92 | wg.Wait()
93 | return &types.SocketMpushReply{
94 | FailureSessionIds: failureSessionIds,
95 | }, nil
96 | }
97 |
98 | // Kick kicks the uid offline.
99 | func Kick(uid string) (existed bool, err error) {
100 | sess, existed := outerPeer.GetSession(uid)
101 | if existed {
102 | err = sess.Close()
103 | }
104 | return existed, err
105 | }
106 |
107 | // SocketKick kicks the uid offline.
108 | func (g *gw) SocketKick(args *types.SocketKickArgs) (*types.SocketKickReply, *erpc.Status) {
109 | existed, _ := Kick(args.SessionId)
110 | return &types.SocketKickReply{
111 | Existed: existed,
112 | }, nil
113 | }
114 |
--------------------------------------------------------------------------------
/gateway/gateway.go:
--------------------------------------------------------------------------------
1 | // Package gateway is the main program for TCP and HTTP services.
2 | //
3 | // Copyright 2018 github.com/xiaoenai. All Rights Reserved.
4 | //
5 | // Licensed under the Apache License, Version 2.0 (the "License");
6 | // you may not use this file except in compliance with the License.
7 | // You may obtain a copy of the License at
8 | //
9 | // http://www.apache.org/licenses/LICENSE-2.0
10 | //
11 | // Unless required by applicable law or agreed to in writing, software
12 | // distributed under the License is distributed on an "AS IS" BASIS,
13 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 | // See the License for the specific language governing permissions and
15 | // limitations under the License.
16 | //
17 | package gateway
18 |
19 | import (
20 | _ "unsafe"
21 |
22 | "github.com/henrylee2cn/erpc/v6"
23 | // "github.com/henrylee2cn/erpc/v6/proto/httproto"
24 | "github.com/henrylee2cn/erpc/v6/mixer/websocket/jsonSubProto"
25 | "github.com/henrylee2cn/erpc/v6/proto/rawproto"
26 | "github.com/xiaoenai/tp-micro/v6/clientele"
27 | "github.com/xiaoenai/tp-micro/v6/gateway/logic"
28 | "github.com/xiaoenai/tp-micro/v6/gateway/logic/hosts"
29 | short "github.com/xiaoenai/tp-micro/v6/gateway/logic/http"
30 | long "github.com/xiaoenai/tp-micro/v6/gateway/logic/socket"
31 | ws "github.com/xiaoenai/tp-micro/v6/gateway/logic/websocket"
32 | "github.com/xiaoenai/tp-micro/v6/gateway/sdk"
33 | "github.com/xiaoenai/tp-micro/v6/gateway/types"
34 | )
35 |
36 | // Run the gateway main program.
37 | // If protoFunc=nil, rawproto.NewRawProtoFunc is used by default.
38 | // If biz=nil, types.DefaultBusiness() is used by default.
39 | func Run(cfg Config, biz *types.Business, protoFunc, wsProtoFunc erpc.ProtoFunc) error {
40 | // config
41 | err := cfg.check()
42 | if err != nil {
43 | return err
44 | }
45 |
46 | // protocol
47 | if protoFunc == nil {
48 | protoFunc = rawproto.NewRawProtoFunc()
49 | }
50 |
51 | // client
52 | clientele.SetProtoFunc(protoFunc)
53 |
54 | // business
55 | if biz == nil {
56 | biz = types.DefaultBusiness()
57 | }
58 | logic.SetBusiness(biz)
59 |
60 | // sdk version
61 | sdk.SetApiVersion(logic.ApiVersion())
62 |
63 | var (
64 | httpAddr string
65 | outerSocketAddr string
66 | innerSocketAddr string
67 | webSocketAddr string
68 | )
69 |
70 | // HTTP server
71 | if cfg.EnableHttp {
72 | httpAddr = cfg.OuterHttpServer.OuterIpPort()
73 | go short.Serve(cfg.OuterHttpServer)
74 | }
75 |
76 | // TCP socket server
77 | if cfg.EnableSocket {
78 | outerSocketAddr = cfg.OuterSocketServer.OuterIpPort()
79 | innerSocketAddr = cfg.InnerSocketServer.InnerIpPort()
80 | go long.Serve(
81 | cfg.OuterSocketServer,
82 | cfg.InnerSocketServer,
83 | protoFunc,
84 | )
85 | }
86 |
87 | // web socket proto func
88 | if wsProtoFunc == nil {
89 | wsProtoFunc = jsonSubProto.NewJSONSubProtoFunc()
90 | }
91 | // web socket server
92 | if cfg.EnableWebSocket {
93 | webSocketAddr = cfg.WebSocketServer.OuterIpPort()
94 | go ws.Serve(
95 | cfg.WebSocketServer,
96 | wsProtoFunc,
97 | )
98 | }
99 |
100 | hosts.Start(
101 | httpAddr,
102 | outerSocketAddr,
103 | innerSocketAddr,
104 | webSocketAddr,
105 | )
106 |
107 | select {}
108 | }
109 |
110 | // RegBodyCodecForHTTP registers a mapping of content type to body coder (for http).
111 | func RegBodyCodecForHTTP(contentType string, codecId byte) {
112 | short.RegBodyCodec(contentType, codecId)
113 | }
114 |
115 | // TotalConn returns the current connections amount.
116 | func TotalConn() int32
117 |
118 | // HostsNamespace returns the gateway hosts prefix of ETCD key.
119 | func HostsNamespace() string {
120 | return hosts.HostsNamespace()
121 | }
122 |
123 | // SetHostsNamespace sets the gateway hosts prefix of ETCD key.
124 | func SetHostsNamespace(prefix string) {
125 | hosts.SetHostsNamespace(prefix)
126 | }
127 |
--------------------------------------------------------------------------------
/gateway/types/conn_hooks.go:
--------------------------------------------------------------------------------
1 | // Copyright 2018 github.com/xiaoenai. All Rights Reserved.
2 | //
3 | // Licensed under the Apache License, Version 2.0 (the "License");
4 | // you may not use this file except in compliance with the License.
5 | // You may obtain a copy of the License at
6 | //
7 | // http://www.apache.org/licenses/LICENSE-2.0
8 | //
9 | // Unless required by applicable law or agreed to in writing, software
10 | // distributed under the License is distributed on an "AS IS" BASIS,
11 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 | // See the License for the specific language governing permissions and
13 | // limitations under the License.
14 |
15 | package types
16 |
17 | import (
18 | "github.com/henrylee2cn/erpc/v6"
19 | "github.com/henrylee2cn/erpc/v6/plugin/auth"
20 | "github.com/valyala/fasthttp"
21 | micro "github.com/xiaoenai/tp-micro/v6"
22 | )
23 |
24 | // SocketHooks TCP socket connecting event hooks
25 | type SocketHooks interface {
26 | // OnLogon is called when the client goes online.
27 | OnLogon(auth.Session, AccessToken) *erpc.Status
28 | // OnLogoff is called when the client goes offline.
29 | OnLogoff(erpc.BaseSession) *erpc.Status
30 | // GetSession returns session from peer by uid.
31 | GetSession(peer erpc.Peer, uid string) (erpc.Session, *erpc.Status)
32 | //PreWritePush is executed before writing PUSH packet.
33 | PreWritePush(erpc.WriteCtx) *erpc.Status
34 | }
35 |
36 | type (
37 | // HttpHooks HTTP connecting event hooks
38 | HttpHooks interface {
39 | // OnRequest is called when the client requests.
40 | OnRequest(params RequestArgs, body []byte, authFunc AuthFunc) (AccessToken, []erpc.MessageSetting, *erpc.Status)
41 | }
42 | // RequestArgs http query parameters
43 | RequestArgs interface {
44 | // Query returns query arguments from request URI.
45 | QueryArgs() *fasthttp.Args
46 | // Header returns the header object of request.
47 | Header() *fasthttp.RequestHeader
48 | }
49 | )
50 |
51 | // WebSocketHooks WEB socket connecting event hooks
52 | type WebSocketHooks interface {
53 | // OnLogon is called when the client goes online.
54 | OnLogon(auth.Session, AccessToken) *erpc.Status
55 | // OnLogoff is called when the client goes offline.
56 | OnLogoff(erpc.BaseSession) *erpc.Status
57 | // GetSession returns session from peer by uid.
58 | GetSession(peer erpc.Peer, uid string) (erpc.Session, *erpc.Status)
59 | //PreWritePush is executed before writing PUSH packet.
60 | PreWritePush(erpc.WriteCtx) *erpc.Status
61 | }
62 |
63 | // DefaultSocketHooks creates a new default SocketHooks object.
64 | func DefaultSocketHooks() SocketHooks {
65 | return new(defSocketHooks)
66 | }
67 |
68 | // DefaultWebSocketHooks creates a new default WebSocketHooks object.
69 | func DefaultWebSocketHooks() WebSocketHooks {
70 | return new(defSocketHooks)
71 | }
72 |
73 | type defSocketHooks struct{}
74 |
75 | func (d *defSocketHooks) OnLogon(sess auth.Session, accessToken AccessToken) *erpc.Status {
76 | sess.SetID(accessToken.SessionId())
77 | return nil
78 | }
79 |
80 | func (d *defSocketHooks) OnLogoff(erpc.BaseSession) *erpc.Status {
81 | return nil
82 | }
83 |
84 | func (d *defSocketHooks) GetSession(peer erpc.Peer, uid string) (erpc.Session, *erpc.Status) {
85 | sess, ok := peer.GetSession(uid)
86 | if !ok {
87 | return nil, micro.RerrNotOnline
88 | }
89 | return sess, nil
90 | }
91 |
92 | func (d *defSocketHooks) PreWritePush(erpc.WriteCtx) *erpc.Status {
93 | return nil
94 | }
95 |
96 | // DefaultHttpHooks creates a new default HttpHooks object.
97 | func DefaultHttpHooks() HttpHooks {
98 | return new(defHttpHooks)
99 | }
100 |
101 | type defHttpHooks struct{}
102 |
103 | func (d *defHttpHooks) OnRequest(params RequestArgs, body []byte, authFunc AuthFunc) (AccessToken, []erpc.MessageSetting, *erpc.Status) {
104 | accessToken, stat := authFunc(string(params.QueryArgs().Peek("access_token")))
105 | return accessToken, nil, stat
106 | }
107 |
--------------------------------------------------------------------------------
/examples/custom/server.go:
--------------------------------------------------------------------------------
1 | package main
2 |
3 | import (
4 | "encoding/json"
5 | "time"
6 |
7 | "github.com/henrylee2cn/cfgo"
8 | "github.com/henrylee2cn/erpc/v6"
9 | "github.com/henrylee2cn/erpc/v6/codec"
10 | micro "github.com/xiaoenai/tp-micro/v6"
11 | "github.com/xiaoenai/tp-micro/v6/discovery"
12 | sagent "github.com/xiaoenai/tp-micro/v6/gateway/helper/agent/socket"
13 | gwSdk "github.com/xiaoenai/tp-micro/v6/gateway/sdk"
14 | gwTypes "github.com/xiaoenai/tp-micro/v6/gateway/types"
15 | "github.com/xiaoenai/tp-micro/v6/helper"
16 | html "github.com/xiaoenai/tp-micro/v6/helper/mod-html"
17 | "github.com/xiaoenai/tp-micro/v6/model/etcd"
18 | "github.com/xiaoenai/tp-micro/v6/model/redis"
19 | )
20 |
21 | func init() {
22 | // html.ParseGlob("*.tpl")
23 |
24 | html.Parse("home", `
25 |
26 |
27 | Home
28 |
29 |
30 |
31 | {{.}}
32 |
33 | `)
34 | }
35 |
36 | // Home HTML home page
37 | func Home(ctx erpc.CallCtx, args *struct{}) ([]byte, *erpc.Status) {
38 | return html.Render(ctx, "home", "Home Page Test!")
39 | }
40 |
41 | // Home2 HTML home page
42 | func Home2(ctx erpc.CallCtx, args *struct{}) ([]byte, *erpc.Status) {
43 | return nil, helper.Redirect(ctx, 302, "http://localhost:5000/home")
44 | }
45 |
46 | // Args args
47 | type Args struct {
48 | A int
49 | B int `param:""`
50 | }
51 |
52 | // Math handler
53 | type Math struct {
54 | erpc.CallCtx
55 | }
56 |
57 | // Divide divide API
58 | func (m *Math) Divide(args *Args) (int, *erpc.Status) {
59 | return args.A / args.B, nil
60 | }
61 |
62 | type config struct {
63 | Srv micro.SrvConfig
64 | Cli micro.CliConfig
65 | Etcd etcd.EasyConfig
66 | Redis redis.Config
67 | }
68 |
69 | func (c *config) Reload(bind cfgo.BindFunc) error {
70 | err := bind()
71 | return err
72 | }
73 |
74 | func main() {
75 | cfg := config{
76 | Srv: micro.SrvConfig{
77 | ListenAddress: ":0",
78 | EnableHeartbeat: true,
79 | PrintDetail: true,
80 | },
81 | Cli: micro.CliConfig{},
82 | Etcd: etcd.EasyConfig{
83 | Endpoints: []string{"http://127.0.0.1:2379"},
84 | },
85 | Redis: *redis.NewConfig(),
86 | }
87 | cfgo.AllowAppsShare(true)
88 | cfgo.MustReg("server", &cfg)
89 |
90 | redisClient, err := redis.NewClient(&cfg.Redis)
91 | sagent.Init(redisClient, redisClient)
92 | if err != nil {
93 | erpc.Fatalf("%v", err)
94 | }
95 |
96 | erpc.Go(func() {
97 | agentNewsChan := sagent.Subscribe()
98 | for news := range agentNewsChan {
99 | erpc.Infof("agent news: sessionId:%s, event:%s",
100 | news.SessionId, news.Event,
101 | )
102 | }
103 | })
104 |
105 | p := discovery.ServicePlugin(
106 | cfg.Srv.InnerIpPort(),
107 | cfg.Etcd,
108 | )
109 | srv := micro.NewServer(cfg.Srv, p)
110 | srv.RouteCallFunc(Home)
111 | srv.RouteCallFunc(Home2)
112 | srv.RouteCall(new(Math))
113 | go srv.ListenAndServe()
114 |
115 | // test pushing, when the client progress is existed.
116 | gwSdk.Init("v1", nil)
117 | for i := 0; ; i++ {
118 | erpc.Infof("test pushing msg after 10s")
119 | time.Sleep(time.Second * 10)
120 | push([]string{"client-auth-info-12345"}, &Args{A: i, B: i})
121 | }
122 | select {}
123 | }
124 |
125 | func push(uids []string, args *Args) {
126 | agts, stat := sagent.QueryAgent(uids)
127 | if stat != nil {
128 | erpc.Errorf("push fail: %v", stat)
129 | }
130 | for _, agt := range agts.Agents {
131 | if agt.IsOffline {
132 | continue
133 | }
134 | addr := agt.GetInnerGw()
135 | target := []*gwTypes.MpushTarget{
136 | {
137 | SessionId: agt.GetSessionId(),
138 | AdditionalQuery: "testpush=ok",
139 | },
140 | }
141 | targetUri := "/push"
142 | msgBytes, _ := json.Marshal(args)
143 | _, stat := gwSdk.SocketMpush(
144 | addr,
145 | &gwTypes.SocketMpushArgs{
146 | Target: target,
147 | Uri: targetUri,
148 | Body: msgBytes,
149 | BodyCodec: codec.ID_JSON,
150 | },
151 | erpc.WithBodyCodec(codec.ID_JSON),
152 | )
153 | if stat != nil {
154 | erpc.Errorf("push fail: %v", stat)
155 | } else {
156 | erpc.Infof("push ok")
157 | }
158 | }
159 | }
160 |
--------------------------------------------------------------------------------
/gateway/logic/socket/server.go:
--------------------------------------------------------------------------------
1 | // Copyright 2018 github.com/xiaoenai. All Rights Reserved.
2 | //
3 | // Licensed under the Apache License, Version 2.0 (the "License");
4 | // you may not use this file except in compliance with the License.
5 | // You may obtain a copy of the License at
6 | //
7 | // http://www.apache.org/licenses/LICENSE-2.0
8 | //
9 | // Unless required by applicable law or agreed to in writing, software
10 | // distributed under the License is distributed on an "AS IS" BASIS,
11 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 | // See the License for the specific language governing permissions and
13 | // limitations under the License.
14 |
15 | package socket
16 |
17 | import (
18 | "net"
19 |
20 | "github.com/henrylee2cn/erpc/v6"
21 | "github.com/henrylee2cn/erpc/v6/plugin/auth"
22 | "github.com/henrylee2cn/erpc/v6/plugin/proxy"
23 | micro "github.com/xiaoenai/tp-micro/v6"
24 | "github.com/xiaoenai/tp-micro/v6/clientele"
25 | "github.com/xiaoenai/tp-micro/v6/discovery"
26 | "github.com/xiaoenai/tp-micro/v6/gateway/logic"
27 | websocket "github.com/xiaoenai/tp-micro/v6/gateway/logic/websocket"
28 | )
29 |
30 | var (
31 | outerPeer erpc.Peer
32 | outerServer *micro.Server
33 | clientAuthInfo string
34 | )
35 |
36 | // OuterServeConn serves connetion.
37 | func OuterServeConn(conn net.Conn) {
38 | sess, err := outerServer.ServeConn(conn)
39 | if err != nil {
40 | erpc.Errorf("Serve net.Conn error: %v", err)
41 | }
42 | <-sess.CloseNotify()
43 | }
44 |
45 | // Serve starts TCP gateway service.
46 | func Serve(outerSrvCfg, innerSrvCfg micro.SrvConfig, protoFunc erpc.ProtoFunc) {
47 | outerServer = micro.NewServer(
48 | outerSrvCfg,
49 | authChecker,
50 | socketConnTabPlugin,
51 | proxy.NewPlugin(logic.ProxySelector),
52 | preWritePushPlugin(),
53 | )
54 |
55 | outerPeer = outerServer.Peer()
56 |
57 | innerPlugins := logic.InnerServerPlugins()
58 | discoveryService := discovery.ServicePluginFromEtcd(
59 | innerSrvCfg.InnerIpPort(),
60 | clientele.GetEtcdClient(),
61 | )
62 | innerPlugins = append(innerPlugins, discoveryService)
63 | innerServer := micro.NewServer(
64 | innerSrvCfg,
65 | innerPlugins...,
66 | )
67 |
68 | gwGroup := innerServer.SubRoute("/gw")
69 | {
70 | verGroup := gwGroup.SubRoute(logic.ApiVersion())
71 | {
72 | verGroup.RouteCallFunc((*gw).Hosts)
73 | // socket api
74 | discoveryService.ExcludeApi(verGroup.RouteCallFunc((*gw).SocketTotal))
75 | discoveryService.ExcludeApi(verGroup.RouteCallFunc((*gw).SocketPush))
76 | discoveryService.ExcludeApi(verGroup.RouteCallFunc((*gw).SocketMpush))
77 | discoveryService.ExcludeApi(verGroup.RouteCallFunc((*gw).SocketKick))
78 | // ws api
79 | discoveryService.ExcludeApi(verGroup.RouteCallFunc((*websocket.Gw).WsTotal))
80 | discoveryService.ExcludeApi(verGroup.RouteCallFunc((*websocket.Gw).WsPush))
81 | discoveryService.ExcludeApi(verGroup.RouteCallFunc((*websocket.Gw).WsMpush))
82 | discoveryService.ExcludeApi(verGroup.RouteCallFunc((*websocket.Gw).WsKick))
83 | }
84 | }
85 |
86 | go outerServer.ListenAndServe(protoFunc)
87 | go innerServer.ListenAndServe(protoFunc)
88 |
89 | select {}
90 | }
91 |
92 | // auth plugin
93 | var authChecker = auth.NewCheckerPlugin(
94 | func(sess auth.Session, fn auth.RecvOnce) (ret interface{}, stat *erpc.Status) {
95 | var authInfo string
96 | stat = fn(&authInfo)
97 | if !stat.OK() {
98 | return
99 | }
100 | erpc.Tracef("auth info: %v", authInfo)
101 | stat = socketConnTabPlugin.authAndLogon(authInfo, sess)
102 | if !stat.OK() {
103 | return
104 | }
105 | return "", nil
106 | },
107 | erpc.WithBodyCodec('s'),
108 | )
109 |
110 | // preWritePushPlugin returns PreWritePushPlugin.
111 | func preWritePushPlugin() erpc.Plugin {
112 | return &perPusher{fn: logic.SocketHooks().PreWritePush}
113 | }
114 |
115 | type perPusher struct {
116 | fn func(erpc.WriteCtx) *erpc.Status
117 | }
118 |
119 | func (p *perPusher) Name() string {
120 | return "PUSH-LOGIC"
121 | }
122 |
123 | var (
124 | _ erpc.PreWritePushPlugin = (*perPusher)(nil)
125 | )
126 |
127 | func (p *perPusher) PreWritePush(ctx erpc.WriteCtx) *erpc.Status {
128 | return p.fn(ctx)
129 | }
130 |
--------------------------------------------------------------------------------
/gateway/sdk/rpc.go:
--------------------------------------------------------------------------------
1 | // Copyright 2018 github.com/xiaoenai. All Rights Reserved.
2 | //
3 | // Licensed under the Apache License, Version 2.0 (the "License");
4 | // you may not use this file except in compliance with the License.
5 | // You may obtain a copy of the License at
6 | //
7 | // http://www.apache.org/licenses/LICENSE-2.0
8 | //
9 | // Unless required by applicable law or agreed to in writing, software
10 | // distributed under the License is distributed on an "AS IS" BASIS,
11 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 | // See the License for the specific language governing permissions and
13 | // limitations under the License.
14 |
15 | package sdk
16 |
17 | import (
18 | "path"
19 | "strings"
20 |
21 | "github.com/henrylee2cn/erpc/v6"
22 | "github.com/xiaoenai/tp-micro/v6/clientele"
23 | "github.com/xiaoenai/tp-micro/v6/gateway/types"
24 | )
25 |
26 | // Init initializes a common inner ant client.
27 | func Init(apiVersion string, protoFunc erpc.ProtoFunc) {
28 | clientele.SetProtoFunc(protoFunc)
29 | SetApiVersion(apiVersion)
30 | }
31 |
32 | var _apiVersion string
33 |
34 | // SetApiVersion sets API version
35 | func SetApiVersion(apiVersion string) {
36 | _apiVersion = strings.TrimRight(path.Join("/", apiVersion), "/")
37 | }
38 |
39 | // GwHosts returns the gateway host list.
40 | func GwHosts(setting ...erpc.MessageSetting) (*types.GwHosts, *erpc.Status) {
41 | var reply = new(types.GwHosts)
42 | stat := clientele.DynamicCall(nil, "/gw"+_apiVersion+"/hosts", nil, reply, setting...).Status()
43 | if stat != nil {
44 | return nil, stat
45 | }
46 | return reply, nil
47 | }
48 |
49 | // SocketTotal returns the long connections total of the remote server.
50 | func SocketTotal(srvAddr string, setting ...erpc.MessageSetting) (*types.SocketTotalReply, *erpc.Status) {
51 | var reply = new(types.SocketTotalReply)
52 | stat := clientele.StaticCall(nil, srvAddr, "/gw"+_apiVersion+"/socket_total", nil, reply, setting...).Status()
53 | if stat != nil {
54 | return nil, stat
55 | }
56 | return reply, nil
57 | }
58 |
59 | // SocketPush pushes message to the specified user.
60 | func SocketPush(srvAddr string, args *types.SocketPushArgs, setting ...erpc.MessageSetting) (*types.SocketPushReply, *erpc.Status) {
61 | var reply = new(types.SocketPushReply)
62 | stat := clientele.StaticCall(nil, srvAddr, "/gw"+_apiVersion+"/socket_push", args, reply, setting...).Status()
63 | if stat != nil {
64 | return nil, stat
65 | }
66 | return reply, nil
67 | }
68 |
69 | // SocketMpush multi-push messages to the specified users.
70 | func SocketMpush(srvAddr string, args *types.SocketMpushArgs, setting ...erpc.MessageSetting) (*types.SocketMpushReply, *erpc.Status) {
71 | var reply = new(types.SocketMpushReply)
72 | stat := clientele.StaticCall(nil, srvAddr, "/gw"+_apiVersion+"/socket_mpush", args, reply, setting...).Status()
73 | if stat != nil {
74 | return nil, stat
75 | }
76 | return reply, nil
77 | }
78 |
79 | // WsTotal returns the long connections total of the remote server.
80 | func WsTotal(srvAddr string, setting ...erpc.MessageSetting) (*types.WsTotalReply, *erpc.Status) {
81 | var reply = new(types.WsTotalReply)
82 | stat := clientele.StaticCall(nil, srvAddr, "/gw"+_apiVersion+"/ws_total", nil, reply, setting...).Status()
83 | if stat != nil {
84 | return nil, stat
85 | }
86 | return reply, nil
87 | }
88 |
89 | // WsPush pushes message to the specified user.
90 | func WsPush(srvAddr string, args *types.SocketPushArgs, setting ...erpc.MessageSetting) (*types.WsPushReply, *erpc.Status) {
91 | var reply = new(types.WsPushReply)
92 | stat := clientele.StaticCall(nil, srvAddr, "/gw"+_apiVersion+"/ws_push", args, reply, setting...).Status()
93 | if stat != nil {
94 | return nil, stat
95 | }
96 | return reply, nil
97 | }
98 |
99 | // WsMpush multi-push messages to the specified users.
100 | func WsMpush(srvAddr string, args *types.WsMpushArgs, setting ...erpc.MessageSetting) (*types.WsMpushReply, *erpc.Status) {
101 | var reply = new(types.WsMpushReply)
102 | stat := clientele.StaticCall(nil, srvAddr, "/gw"+_apiVersion+"/ws_mpush", args, reply, setting...).Status()
103 | if stat != nil {
104 | return nil, stat
105 | }
106 | return reply, nil
107 | }
108 |
--------------------------------------------------------------------------------
/configer/node.go:
--------------------------------------------------------------------------------
1 | package configer
2 |
3 | import (
4 | "context"
5 | "encoding/json"
6 | "fmt"
7 | "os"
8 | "sync"
9 |
10 | "github.com/henrylee2cn/erpc/v6"
11 | "github.com/xiaoenai/tp-micro/v6/model/etcd"
12 | )
13 |
14 | // InitNode initializes the config node.
15 | func InitNode(etcdClient *etcd.Client) {
16 | globalNodes = &Nodes{
17 | nodeMap: make(map[string]*Node),
18 | }
19 |
20 | var err error
21 | globalNodes.etcdSession, err = etcd.NewSession(etcdClient)
22 | if err != nil {
23 | erpc.Fatalf("Initialization of the global node failed: %s", err.Error())
24 | }
25 | }
26 |
27 | // SyncNode registers a configuration template to etcd,
28 | // and update it when monitoring the configuration changes.
29 | func SyncNode(service, version string, cfg Config) {
30 | globalNodes.mustAdd(service, version, cfg)
31 | }
32 |
33 | // Nodes config node handlers
34 | type Nodes struct {
35 | nodeMap map[string]*Node
36 | etcdSession *etcd.Session
37 | rwMutex sync.RWMutex
38 | }
39 |
40 | var globalNodes *Nodes
41 |
42 | func (n *Nodes) mustAdd(service, version string, cfg Config) {
43 | must(n.add(service, version, cfg))
44 | }
45 |
46 | func (n *Nodes) add(service, version string, cfg Config) (err error) {
47 | n.rwMutex.Lock()
48 | defer n.rwMutex.Unlock()
49 |
50 | key := NewKey(service, version)
51 | if _, ok := n.nodeMap[key]; ok {
52 | return fmt.Errorf("Repeat the registration configuration: %s", key)
53 | }
54 | cfgBytes, _ := cfg.MarshalJSON()
55 | node := &Node{
56 | key: key,
57 | object: cfg,
58 | etcdMutex: etcd.NewLocker(n.etcdSession, key),
59 | Initialized: false,
60 | Config: string(cfgBytes),
61 | doInitCh: make(chan error, 1),
62 | nodes: n,
63 | }
64 | n.nodeMap[key] = node
65 |
66 | defer func() {
67 | if p := recover(); p != nil {
68 | err = fmt.Errorf("etcd concurrency lock fail: %v", p)
69 | }
70 | }()
71 |
72 | node.etcdMutex.Lock()
73 | defer node.etcdMutex.Unlock()
74 |
75 | resp, err := n.etcdSession.Client().Get(context.TODO(), key)
76 | if err != nil {
77 | return err
78 | }
79 |
80 | if len(resp.Kvs) > 0 {
81 | err = node.bind(resp.Kvs[0].Value)
82 | if node.Initialized {
83 | go node.watch(n.etcdSession.Client())
84 | return err
85 | }
86 |
87 | } else {
88 | _, err = n.etcdSession.Client().Put(context.TODO(), key, node.String())
89 | if err != nil {
90 | return err
91 | }
92 | }
93 |
94 | erpc.Warnf("Wait for the configuration in the ETCD to be set: %s", key)
95 | go node.watch(n.etcdSession.Client())
96 | return node.waitInit()
97 | }
98 |
99 | // Node config node handler
100 | type Node struct {
101 | key string
102 | object Config
103 | // Config string
104 | Config string `json:"config"`
105 | // Is it initialized?
106 | Initialized bool `json:"initialized"`
107 | doInitCh chan error
108 | etcdMutex sync.Locker
109 | nodes *Nodes
110 | }
111 |
112 | func (n *Nodes) archive() {
113 | os.Mkdir("./config", 0755)
114 | r, err := os.OpenFile("./config/archive", os.O_CREATE|os.O_WRONLY|os.O_TRUNC, 0644)
115 | if err != nil {
116 | erpc.Warnf("Archive config error: %v", err)
117 | return
118 | }
119 | b, _ := json.Marshal(n.nodeMap)
120 | r.Write(b)
121 | r.Close()
122 | }
123 |
124 | func (n *Node) bind(data []byte) error {
125 | inited := n.Initialized
126 | err := json.Unmarshal(data, n)
127 | if err != nil {
128 | return err
129 | }
130 |
131 | n.nodes.archive()
132 |
133 | if inited {
134 | err = n.object.Reload([]byte(n.Config))
135 | } else {
136 | err = n.object.UnmarshalJSON([]byte(n.Config))
137 | if n.Initialized {
138 | select {
139 | case n.doInitCh <- err:
140 | default:
141 | }
142 | }
143 | }
144 |
145 | return err
146 | }
147 |
148 | func (n *Node) waitInit() error {
149 | return <-n.doInitCh
150 | }
151 |
152 | // String returns the encoding string
153 | func (n *Node) String() string {
154 | b, _ := json.Marshal(n)
155 | return string(b)
156 | }
157 |
158 | func (n *Node) watch(etcdClient *etcd.Client) {
159 | watcher := etcdClient.Watch(
160 | context.TODO(),
161 | n.key,
162 | )
163 | for wresp := range watcher {
164 | for _, event := range wresp.Events {
165 | if event.Type != etcd.EventTypePut {
166 | continue
167 | }
168 | err := n.bind(event.Kv.Value)
169 | if err != nil {
170 | erpc.Errorf("Binding configuration from etcd failed: %s", err)
171 | }
172 | }
173 | }
174 | }
175 |
--------------------------------------------------------------------------------
/gateway/helper/gray/logic/model/gray_match.go:
--------------------------------------------------------------------------------
1 | package model
2 |
3 | import (
4 | "database/sql"
5 | "time"
6 |
7 | "github.com/henrylee2cn/goutil/coarsetime"
8 | "github.com/henrylee2cn/erpc/v6"
9 | "github.com/xiaoenai/tp-micro/v6/model/mysql"
10 | "github.com/xiaoenai/tp-micro/v6/model/sqlx"
11 | )
12 |
13 | // GrayMatch
14 | type GrayMatch struct {
15 | Uri string `protobuf:"bytes,1,opt,name=Uri,proto3" json:"uri"`
16 | Regexp string `protobuf:"bytes,2,opt,name=Regexp,proto3" json:"regexp"`
17 | CreatedAt int64 `protobuf:"varint,3,opt,name=CreatedAt,proto3" json:"created_at"`
18 | UpdatedAt int64 `protobuf:"varint,4,opt,name=UpdatedAt,proto3" json:"updated_at"`
19 | }
20 |
21 | // TableName implements 'github.com/xiaoenai/tp-micro/model'.Cacheable
22 | func (*GrayMatch) TableName() string {
23 | return "gray_match"
24 | }
25 |
26 | var grayMatchDB, _ = dbHandler.RegCacheableDB(
27 | new(GrayMatch),
28 | time.Hour*24,
29 | `CREATE TABLE IF NOT EXISTS gray_match (
30 | uri VARCHAR(190) COMMENT 'URI',
31 | `+"`regexp`"+` LONGTEXT COMMENT 'regular expression to match UID',
32 | updated_at INT(11) NOT NULL COMMENT 'updated time',
33 | created_at INT(11) NOT NULL COMMENT 'created time',
34 | PRIMARY KEY(uri)
35 | )ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='gray rule';
36 | `)
37 |
38 | // GetGrayMatchDB returns the GrayMatch DB handler.
39 | func GetGrayMatchDB() *mysql.CacheableDB {
40 | return grayMatchDB
41 | }
42 |
43 | // UpsertGrayMatch insert a GrayMatch data into database.
44 | func UpsertGrayMatch(_g *GrayMatch, tx ...*sqlx.Tx) error {
45 | _g.UpdatedAt = coarsetime.FloorTimeNow().Unix()
46 | if _g.CreatedAt == 0 {
47 | _g.CreatedAt = _g.UpdatedAt
48 | }
49 | return grayMatchDB.TransactCallback(func(tx *sqlx.Tx) error {
50 | query := "INSERT INTO `gray_match` (`uri`,`regexp`,`updated_at`,`created_at`)VALUES(:uri,:regexp,:updated_at,:created_at)\n" +
51 | "ON DUPLICATE KEY UPDATE `regexp`=VALUES(`regexp`),`updated_at`=VALUES(`updated_at`);"
52 | _, err := tx.NamedExec(query, _g)
53 | if err != nil {
54 | return err
55 | }
56 | return grayMatchDB.PutCache(_g)
57 | }, tx...)
58 | }
59 |
60 | // UpdateGrayMatchByUri update the GrayMatch data in database by id.
61 | func UpdateGrayMatchByUri(_g *GrayMatch, tx ...*sqlx.Tx) error {
62 | return grayMatchDB.TransactCallback(func(tx *sqlx.Tx) error {
63 | _g.UpdatedAt = coarsetime.FloorTimeNow().Unix()
64 | _, err := tx.NamedExec("UPDATE `gray_match` SET `uri`=:uri,`regexp`=:regexp,`created_at`=:created_at,`updated_at`=:updated_at WHERE uri=:uri LIMIT 1;", _g)
65 | if err != nil {
66 | return err
67 | }
68 | return grayMatchDB.PutCache(_g)
69 | }, tx...)
70 | }
71 |
72 | // DeleteGrayMatchByUri delete a GrayMatch data in database by id.
73 | func DeleteGrayMatchByUri(uri string, tx ...*sqlx.Tx) error {
74 | return grayMatchDB.TransactCallback(func(tx *sqlx.Tx) error {
75 | _, err := tx.Exec("DELETE FROM `gray_match` WHERE uri=?;", uri)
76 | if err != nil {
77 | return err
78 | }
79 | return grayMatchDB.PutCache(&GrayMatch{
80 | Uri: uri,
81 | })
82 | }, tx...)
83 | }
84 |
85 | // GetGrayMatchByUri query a GrayMatch data from database by id.
86 | // If @reply bool=false error=nil, means the data is not exist.
87 | func GetGrayMatchByUri(uri string) (*GrayMatch, bool, error) {
88 | var _g = &GrayMatch{
89 | Uri: uri,
90 | }
91 | err := grayMatchDB.CacheGet(_g)
92 | switch err {
93 | case nil:
94 | if _g.CreatedAt == 0 {
95 | return nil, false, nil
96 | }
97 | return _g, true, nil
98 | case sql.ErrNoRows:
99 | err2 := grayMatchDB.PutCache(_g)
100 | if err2 != nil {
101 | erpc.Errorf("%s", err2.Error())
102 | }
103 | return nil, false, nil
104 | default:
105 | return nil, false, err
106 | }
107 | }
108 |
109 | // GetGrayMatchByWhere query a GrayMatch data from database by WHERE condition.
110 | // If @reply bool=false error=nil, means the data is not exist.
111 | func GetGrayMatchByWhere(whereCond string, args ...interface{}) (*GrayMatch, bool, error) {
112 | var _g = new(GrayMatch)
113 | err := grayMatchDB.Get(_g, "SELECT `uri`,`regexp`,`created_at`,`updated_at` FROM `gray_match` WHERE "+whereCond+" LIMIT 1;", args...)
114 | switch err {
115 | case nil:
116 | return _g, true, nil
117 | case sql.ErrNoRows:
118 | return nil, false, nil
119 | default:
120 | return nil, false, err
121 | }
122 | }
123 |
124 | // SelectGrayMatchByWhere query some GrayMatch data from database by WHERE condition.
125 | func SelectGrayMatchByWhere(whereCond string, args ...interface{}) ([]*GrayMatch, error) {
126 | var objs = new([]*GrayMatch)
127 | err := grayMatchDB.Select(objs, "SELECT `uri`,`regexp`,`created_at`,`updated_at` FROM `gray_match` WHERE "+whereCond, args...)
128 | return *objs, err
129 | }
130 |
131 | // CountGrayMatchByWhere count GrayMatch data number from database by WHERE condition.
132 | func CountGrayMatchByWhere(whereCond string, args ...interface{}) (int64, error) {
133 | var count int64
134 | err := grayMatchDB.Get(&count, "SELECT count(1) FROM `gray_match` WHERE "+whereCond, args...)
135 | return count, err
136 | }
137 |
--------------------------------------------------------------------------------