xinyin025/hotgo
1
0
Fork 0
mirror of https://github.com/bufanyun/hotgo.git synced 2025-12-07 16:56:31 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

发布v2.8.4版本，更新内容请查看：https://github.com/bufanyun/hotgo/tree/v2.0/docs/guide-zh-CN/addon-version-upgrade.md

Browse Source
This commit is contained in:
孟帅
2023-07-20 18:01:10 +08:00
parent 9113fc5297
commit 373d9627fb
492 changed files with 12170 additions and 6982 deletions
Download Patch File Download Diff File Expand all files Collapse all files

82
server/internal/logic/tcpclient/auth.go
View File

@@ -1,10 +1,17 @@
// Package tcpclient
// @Link https://github.com/bufanyun/hotgo
// @Copyright Copyright (c) 2023 HotGo CLI
// @Author Ms <133814250@qq.com>
// @License https://github.com/bufanyun/hotgo/blob/master/LICENSE
package tcpclient
import (
"context"
"github.com/gogf/gf/v2/frame/g"
"github.com/gogf/gf/v2/os/gctx"
"hotgo/api/servmsg"
"hotgo/internal/library/network/tcp"
"hotgo/internal/model/input/msgin"
"hotgo/internal/model/input/servmsgin"
"hotgo/internal/service"
"hotgo/utility/simple"
)
@@ -12,7 +19,7 @@ import (
// tcp客户端
type sAuthClient struct {
client *tcp.Client
summary *msgin.AuthSummaryData
summary *servmsgin.AuthSummaryModel
}
func init() {
@@ -23,6 +30,11 @@ func newAuthClient() *sAuthClient {
return &sAuthClient{}
}
// Instance 获取实例
func (s *sAuthClient) Instance() *tcp.Client {
return s.client
}
// Start 启动服务
func (s *sAuthClient) Start(ctx context.Context) {
g.Log().Debug(ctx, "AuthClient start..")
@@ -38,39 +50,37 @@ func (s *sAuthClient) Start(ctx context.Context) {
return
}
simple.SafeGo(ctx, func(ctx context.Context) {
s.client, err = tcp.NewClient(&tcp.ClientConfig{
Addr: config.Client.Auth.Address,
Auth: &tcp.AuthMeta{
Group: config.Client.Auth.Group,
Name: config.Client.Auth.Name,
AppId: config.Client.Auth.AppId,
SecretKey: config.Client.Auth.SecretKey,
// 创建客户端配置
clientConfig := &tcp.ClientConfig{
Addr: config.Client.Auth.Address,
AutoReconnect: true,
Auth: &tcp.AuthMeta{
Name: config.Client.Auth.Name,
Extra: g.Map{
"test": 13,
},
LoginEvent: s.onLoginEvent,
CloseEvent: s.onCloseEvent,
})
Group: config.Client.Auth.Group,
AppId: config.Client.Auth.AppId,
SecretKey: config.Client.Auth.SecretKey,
},
LoginEvent: s.onLoginEvent,
CloseEvent: s.onCloseEvent,
}
if err != nil {
g.Log().Errorf(ctx, "AuthClient NewClient fail：%+v", err)
return
}
simple.SafeGo(ctx, func(ctx context.Context) {
s.client = tcp.NewClient(clientConfig)
err = s.client.RegisterRouter(map[string]tcp.RouterHandler{
"ResponseAuthSummary": s.OnResponseAuthSummary,
})
if err != nil {
g.Log().Errorf(ctx, "AuthClient RegisterRouter fail：%+v", err)
return
}
// 注册路由
s.client.RegisterRouter(
s.OnResponseAuthSummary, // 响应授权信息
s.OnResponseExampleHello, // 一个tcp请求例子
)
if err = s.client.Start(); err != nil {
g.Log().Errorf(ctx, "AuthClient Start fail：%+v", err)
return
}
})
}
// Stop 停止服务
@@ -81,22 +91,20 @@ func (s *sAuthClient) Stop(ctx context.Context) {
}
}
// IsLogin 是否已登录认证
func (s *sAuthClient) IsLogin() bool {
if s.client == nil {
return false
}
return s.client.IsLogin
}
// onLoginEvent 登录认证成功事件
func (s *sAuthClient) onLoginEvent() {
ctx := gctx.New()
// 获取授权数据
_ = s.client.Send(s.client.Ctx, &msgin.AuthSummary{})
// 获取授权信息
s.client.Send(ctx, &servmsg.AuthSummaryReq{})
// 测试例子，实际使用时可以注释掉
s.testExample(ctx)
g.Log().Debug(ctx, "AuthClient login succeed.")
}
// onCloseEvent 连接关闭回调事件
func (s *sAuthClient) onCloseEvent() {
// ...
g.Log().Debug(gctx.New(), "AuthClient closed.")
}

56
server/internal/logic/tcpclient/auth_handle.go
View File

@@ -1,24 +1,54 @@
// Package tcpclient
// @Link https://github.com/bufanyun/hotgo
// @Copyright Copyright (c) 2023 HotGo CLI
// @Author Ms <133814250@qq.com>
// @License https://github.com/bufanyun/hotgo/blob/master/LICENSE
package tcpclient
import (
"context"
"github.com/gogf/gf/v2/util/gconv"
"hotgo/internal/model/input/msgin"
"github.com/gogf/gf/v2/frame/g"
"hotgo/api/servmsg"
)
// OnResponseAuthSummary 获取授权信息
func (s *sAuthClient) OnResponseAuthSummary(ctx context.Context, args ...interface{}) {
var in *msgin.ResponseAuthSummary
if err := gconv.Scan(args[0], &in); err != nil {
s.client.Logger.Warningf(ctx, "OnResponseAuthSummary Scan err:%+v", err)
return
}
if err := in.GetError(); err != nil {
s.client.Logger.Warningf(ctx, "OnResponseAuthSummary GetError:%+v", err)
// OnResponseAuthSummary 响应授权信息
func (s *sAuthClient) OnResponseAuthSummary(ctx context.Context, req *servmsg.AuthSummaryRes) {
if err := req.GetError(); err != nil {
g.Log().Warningf(ctx, "OnResponseAuthSummary GetError:%+v", err)
return
}
// 拿到授权的数据，可以是一些动态的功能、路由、权限控制等
s.summary = in.Data
s.summary = req.Data
}
// OnResponseExampleHello 一个tcp请求例子
func (s *sAuthClient) OnResponseExampleHello(ctx context.Context, req *servmsg.ExampleHelloRes) {
if err := req.GetError(); err != nil {
g.Log().Warningf(ctx, "OnResponseExampleHello GetError:%+v", err)
return
}
g.Log().Infof(ctx, "OnResponseExampleHello data:%+v", req.Data)
}
// testExample 测试例子
func (s *sAuthClient) testExample(ctx context.Context) {
// 发起tcp请求
// 异步执行，服务端返回消息后会转到`OnResponseExampleHello`中
s.client.Send(ctx, &servmsg.ExampleHelloReq{
Name: "Tom",
})
// 发起rpc请求
// 同步执行，阻塞等待服务端返回消息
var req = &servmsg.ExampleRPCHelloReq{
Name: "Tony",
}
var res *servmsg.ExampleRPCHelloRes
if err := s.client.RequestScan(ctx, req, &res); err != nil {
g.Log().Warningf(ctx, "client.Request ExampleRPCHelloReq err:%+v", err)
return
}
g.Log().Infof(ctx, "ExampleRPCHelloRes data:%+v", res.Data)
}

5
server/internal/logic/tcpclient/client.go
View File

@@ -1 +1,6 @@
// Package tcpclient
// @Link https://github.com/bufanyun/hotgo
// @Copyright Copyright (c) 2023 HotGo CLI
// @Author Ms <133814250@qq.com>
// @License https://github.com/bufanyun/hotgo/blob/master/LICENSE
package tcpclient

74
server/internal/logic/tcpclient/cron.go
View File

@@ -1,8 +1,14 @@
// Package tcpclient
// @Link https://github.com/bufanyun/hotgo
// @Copyright Copyright (c) 2023 HotGo CLI
// @Author Ms <133814250@qq.com>
// @License https://github.com/bufanyun/hotgo/blob/master/LICENSE
package tcpclient
import (
"context"
"github.com/gogf/gf/v2/frame/g"
"github.com/gogf/gf/v2/os/gctx"
"hotgo/internal/library/network/tcp"
"hotgo/internal/service"
"hotgo/utility/simple"
@@ -21,6 +27,11 @@ func newCronClient() *sCronClient {
return &sCronClient{}
}
// Instance 获取实例
func (s *sCronClient) Instance() *tcp.Client {
return s.client
}
// Start 启动服务
func (s *sCronClient) Start(ctx context.Context) {
g.Log().Debug(ctx, "CronClient start..")
@@ -36,42 +47,39 @@ func (s *sCronClient) Start(ctx context.Context) {
return
}
// 创建客户端配置
clientConfig := &tcp.ClientConfig{
Addr: config.Client.Cron.Address,
AutoReconnect: true,
Auth: &tcp.AuthMeta{
Name: config.Client.Cron.Name,
Group: config.Client.Cron.Group,
AppId: config.Client.Cron.AppId,
SecretKey: config.Client.Cron.SecretKey,
},
LoginEvent: s.onLoginEvent,
CloseEvent: s.onCloseEvent,
}
simple.SafeGo(ctx, func(ctx context.Context) {
s.client, err = tcp.NewClient(&tcp.ClientConfig{
Addr: config.Client.Cron.Address,
Auth: &tcp.AuthMeta{
Group: config.Client.Cron.Group,
Name: config.Client.Cron.Name,
AppId: config.Client.Cron.AppId,
SecretKey: config.Client.Cron.SecretKey,
},
LoginEvent: s.onLoginEvent,
CloseEvent: s.onCloseEvent,
})
s.client = tcp.NewClient(clientConfig)
if err != nil {
g.Log().Errorf(ctx, "CronClient NewClient fail：%+v", err)
return
}
// 注册RPC路由
s.client.RegisterRPCRouter(
s.OnCronDelete, // 删除任务
s.OnCronEdit, // 编辑任务
s.OnCronStatus, // 修改任务状态
s.OnCronOnlineExec, // 执行一次任务
)
err = s.client.RegisterRouter(map[string]tcp.RouterHandler{
"CronDelete": s.OnCronDelete, // 删除任务
"CronEdit": s.OnCronEdit, // 编辑任务
"CronStatus": s.OnCronStatus, // 修改任务状态
"CronOnlineExec": s.OnCronOnlineExec, // 执行一次任务
})
if err != nil {
g.Log().Errorf(ctx, "CronClient RegisterRouter fail：%+v", err)
return
}
// 注册拦截器
s.client.RegisterInterceptor(s.DefaultInterceptor)
if err = s.client.Start(); err != nil {
g.Log().Errorf(ctx, "CronClient Start fail：%+v", err)
return
}
})
}
// Stop 停止服务
@@ -82,20 +90,12 @@ func (s *sCronClient) Stop(ctx context.Context) {
}
}
// IsLogin 是否已登录认证
func (s *sCronClient) IsLogin() bool {
if s.client == nil {
return false
}
return s.client.IsLogin
}
// onLoginEvent 登录认证成功事件
func (s *sCronClient) onLoginEvent() {
// ...
g.Log().Debug(gctx.New(), "CronClient login succeed.")
}
// onCloseEvent 连接关闭回调事件
func (s *sCronClient) onCloseEvent() {
// ...
g.Log().Debug(gctx.New(), "CronClient closed.")
}

96
server/internal/logic/tcpclient/cron_handle.go
View File

@@ -1,96 +1,36 @@
// Package tcpclient
// @Link https://github.com/bufanyun/hotgo
// @Copyright Copyright (c) 2023 HotGo CLI
// @Author Ms <133814250@qq.com>
// @License https://github.com/bufanyun/hotgo/blob/master/LICENSE
package tcpclient
import (
"context"
"github.com/gogf/gf/v2/util/gconv"
"hotgo/internal/model/input/msgin"
"hotgo/api/servmsg"
"hotgo/internal/service"
)
// OnCronDelete 删除任务
func (s *sCronClient) OnCronDelete(ctx context.Context, args ...interface{}) {
var (
in *msgin.CronDelete
res = new(msgin.ResponseCronDelete)
)
if err := gconv.Scan(args[0], &in); err != nil {
res.Code = 1
res.Message = err.Error()
_ = s.client.Reply(ctx, res)
return
}
if err := service.SysCron().Delete(ctx, in.CronDeleteInp); err != nil {
res.Code = 2
res.Message = err.Error()
}
_ = s.client.Reply(ctx, res)
func (s *sCronClient) OnCronDelete(ctx context.Context, req *servmsg.CronDeleteReq) (res *servmsg.CronDeleteRes, err error) {
err = service.SysCron().Delete(ctx, req.CronDeleteInp)
return
}
// OnCronEdit 编辑任务
func (s *sCronClient) OnCronEdit(ctx context.Context, args ...interface{}) {
var (
in *msgin.CronEdit
res = new(msgin.ResponseCronEdit)
)
if err := gconv.Scan(args[0], &in); err != nil {
res.Code = 1
res.Message = err.Error()
_ = s.client.Reply(ctx, res)
return
}
if err := service.SysCron().Edit(ctx, in.CronEditInp); err != nil {
res.Code = 2
res.Message = err.Error()
}
_ = s.client.Reply(ctx, res)
func (s *sCronClient) OnCronEdit(ctx context.Context, req *servmsg.CronEditReq) (res *servmsg.CronEditRes, err error) {
err = service.SysCron().Edit(ctx, req.CronEditInp)
return
}
// OnCronStatus 修改任务状态
func (s *sCronClient) OnCronStatus(ctx context.Context, args ...interface{}) {
var (
in *msgin.CronStatus
res = new(msgin.ResponseCronStatus)
)
if err := gconv.Scan(args[0], &in); err != nil {
res.Code = 1
res.Message = err.Error()
_ = s.client.Reply(ctx, res)
return
}
if err := service.SysCron().Status(ctx, in.CronStatusInp); err != nil {
res.Code = 2
res.Message = err.Error()
}
_ = s.client.Reply(ctx, res)
func (s *sCronClient) OnCronStatus(ctx context.Context, req *servmsg.CronStatusReq) (res *servmsg.CronStatusRes, err error) {
err = service.SysCron().Status(ctx, req.CronStatusInp)
return
}
// OnCronOnlineExec 执行一次任务
func (s *sCronClient) OnCronOnlineExec(ctx context.Context, args ...interface{}) {
var (
in *msgin.CronOnlineExec
res = new(msgin.ResponseCronOnlineExec)
)
if err := gconv.Scan(args[0], &in); err != nil {
res.Code = 1
res.Message = err.Error()
_ = s.client.Reply(ctx, res)
return
}
if err := service.SysCron().OnlineExec(ctx, in.OnlineExecInp); err != nil {
res.Code = 1
res.Message = err.Error()
}
_ = s.client.Reply(ctx, res)
func (s *sCronClient) OnCronOnlineExec(ctx context.Context, req *servmsg.CronOnlineExecReq) (res *servmsg.CronOnlineExecRes, err error) {
err = service.SysCron().OnlineExec(ctx, req.OnlineExecInp)
return
}

18
server/internal/logic/tcpclient/cron_interceptor.go Normal file
View File

@@ -0,0 +1,18 @@
// Package tcpclient
// @Link https://github.com/bufanyun/hotgo
// @Copyright Copyright (c) 2023 HotGo CLI
// @Author Ms <133814250@qq.com>
// @License https://github.com/bufanyun/hotgo/blob/master/LICENSE
package tcpclient
import (
"context"
"hotgo/internal/library/network/tcp"
)
// DefaultInterceptor 默认拦截器
func (s *sCronClient) DefaultInterceptor(ctx context.Context, msg *tcp.Message) (err error) {
//conn := tcp.ConnFromCtx(ctx)
//g.Log().Debugf(ctx, "DefaultInterceptor msg:%+v, conn:%+v", msg, gjson.New(conn).String())
return
}