pro/im_manager
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: 完成鸽达达后台安全与审计改造

Browse Source
This commit is contained in:
richjohnrambo
2026-09-07 11:50:29 +08:00
parent ab2b84c9fa
commit bb87d01644
196 changed files with 19970 additions and 280 deletions
Download Patch File Download Diff File Expand all files Collapse all files
server/internal/library/casbin/casbin_test.go
+46 -47
View File
@@ -1,67 +1,66 @@
// Package casbin
// @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 casbin
import (
"context"
"net/http"
"testing"
casbinv2 "github.com/casbin/casbin/v2"
"github.com/casbin/casbin/v2/model"
)
// TestNew description
func TestNew(t *testing.T) {
const testModel = `
[request_definition]
r = sub, obj, act
InitEnforcer(context.TODO())
[policy_definition]
p = sub, obj, act
user := "admin"
path := "/"
method := http.MethodGet
t.Logf("\nuser:%v\npath:%v\nmethod:%v", user, path, method)
[role_definition]
g = _, _
ok, err := Enforcer.DeletePermissionsForUser(user)
[policy_effect]
e = some(where (p.eft == allow))
[matchers]
m = g(r.sub, p.sub) && keyMatch(r.obj, p.obj) && regexMatch(r.act, p.act)
`
func TestEnforcerPermissions(t *testing.T) {
m, err := model.NewModelFromString(testModel)
if err != nil {
t.Error(err)
t.Fatalf("创建Casbin测试模型失败: %v", err)
}
t.Logf("delete user premission:%v", ok)
CheckPremission(t, user, path, method)
AddPremission(t, user, "*", ActionAll)
CheckPremission(t, user, path, method)
user1 := "user1"
path1 := "/api/v1/*"
checkPathTrue := "/api/v1/user/list"
checkPathFalse := "/api/v2/user/list"
AddPremission(t, user1, path1, ActionAll)
CheckPremission(t, user1, checkPathTrue, ActionPost)
CheckPremission(t, user1, checkPathFalse, http.MethodGet)
CheckPremission(t, user1, checkPathTrue, http.MethodGet)
CheckPremission(t, user1, "/api/v1/user/list2", http.MethodGet)
ok, err = Enforcer.DeletePermissionsForUser(user1)
enforcer, err := casbinv2.NewEnforcer(m)
if err != nil {
t.Error(err)
t.Fatalf("创建Casbin测试实例失败: %v", err)
}
t.Logf("delete user premission:%v", ok)
CheckPremission(t, user1, "/api/v1/user1/list", http.MethodGet)
assertPermission(t, enforcer, "admin", "/", http.MethodGet, false)
if ok, addErr := enforcer.AddPolicy("admin", "*", ActionAll); addErr != nil || !ok {
t.Fatalf("添加管理员策略失败: ok=%v err=%v", ok, addErr)
}
assertPermission(t, enforcer, "admin", "/", http.MethodGet, true)
if ok, addErr := enforcer.AddPolicy("user1", "/api/v1/*", ActionAll); addErr != nil || !ok {
t.Fatalf("添加用户策略失败: ok=%v err=%v", ok, addErr)
}
assertPermission(t, enforcer, "user1", "/api/v1/user/list", http.MethodPost, true)
assertPermission(t, enforcer, "user1", "/api/v1/user/list", http.MethodGet, true)
assertPermission(t, enforcer, "user1", "/api/v2/user/list", http.MethodGet, false)
if ok, deleteErr := enforcer.DeletePermissionsForUser("user1"); deleteErr != nil || !ok {
t.Fatalf("删除用户策略失败: ok=%v err=%v", ok, deleteErr)
}
assertPermission(t, enforcer, "user1", "/api/v1/user/list", http.MethodGet, false)
}
// CheckPremission description
func CheckPremission(t *testing.T, user string, path string, method string) {
ok, err := Enforcer.Enforce(user, path, method)
func assertPermission(t *testing.T, enforcer *casbinv2.Enforcer, user, path, method string, expected bool) {
t.Helper()
actual, err := enforcer.Enforce(user, path, method)
if err != nil {
t.Error(err)
t.Fatalf("检查权限失败: %v", err)
}
t.Logf("check \tuser[%s] \tpremission[%s] \tpath[%s] \tallow[%v]", user, method, path, ok)
}
// Add description
func AddPremission(t *testing.T, user string, path string, method string) {
ok, err := Enforcer.AddPolicy(user, path, method)
if err != nil {
t.Error(err)
if actual != expected {
t.Fatalf("权限结果不符 user=%s path=%s method=%s expected=%v actual=%v", user, path, method, expected, actual)
}
t.Logf("add \tuser[%s] \tpremission[%s] \tpath[%s] \tresult[%v]", user, method, path, ok)
}
server/internal/library/network/tcp/client.go
+2
View File
@@ -281,6 +281,8 @@ func (client *Client) handleRoutineTask(ctx context.Context, task func()) {
// Conn 获取当前连接
func (client *Client) Conn() *Conn {
client.mutex.Lock()
defer client.mutex.Unlock()
return client.conn
}
server/internal/library/network/tcp/rpc.go
+6 -2
View File
@@ -43,7 +43,6 @@ func (r *RPC) Request(ctx context.Context, msgId string, send func()) (res inter
defer func() {
isClose.Set(true)
close(resCh)
r.popCallback(msgId)
}()
@@ -57,8 +56,13 @@ func (r *RPC) Request(ctx context.Context, msgId string, send func()) (res inter
r.task(ctx, send)
timer := time.NewTimer(time.Second * RPCTimeout)
defer timer.Stop()
select {
case <-time.After(time.Second * RPCTimeout):
case <-ctx.Done():
err = gerror.Wrap(ctx.Err(), "RPC request canceled")
return
case <-timer.C:
err = gerror.New("RPC response timeout")
return
case got := <-resCh:
server/internal/library/network/tcp/tcp_example_test.go
+84 -97
View File
@@ -1,21 +1,14 @@
// Package tcp_test
// @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 tcp_test
import (
"context"
"fmt"
"github.com/gogf/gf/v2/os/gctx"
"github.com/gogf/gf/v2/test/gtest"
"hotgo/internal/library/network/tcp"
"net"
"testing"
"time"
)
var T *testing.T // 声明一个全局的 *testing.T 变量
"hotgo/internal/library/network/tcp"
)
type TestMsgReq struct {
Name string `json:"name"`
@@ -33,101 +26,95 @@ type TestRPCMsgRes struct {
tcp.ServerRes
}
func onTestMsg(ctx context.Context, req *TestMsgReq) {
fmt.Printf("服务器收到消息 ==> onTestMsg:%+v\n", req)
conn := tcp.ConnFromCtx(ctx)
gtest.C(T, func(t *gtest.T) {
t.AssertNE(conn, nil)
})
res := new(TestMsgRes)
res.Message = fmt.Sprintf("你的名字：%v", req.Name)
conn.Send(ctx, res)
}
func onResponseTestMsg(ctx context.Context, req *TestMsgRes) {
fmt.Printf("客户端收到响应消息 ==> TestMsgRes:%+v\n", req)
err := req.GetError()
gtest.C(T, func(t *gtest.T) {
t.AssertNil(err)
})
}
func onTestRPCMsg(ctx context.Context, req *TestRPCMsgReq) (res *TestRPCMsgRes, err error) {
fmt.Printf("服务器收到消息 ==> onTestRPCMsg:%+v\n", req)
res = new(TestRPCMsgRes)
res.Message = fmt.Sprintf("你的名字：%v", req.Name)
return
}
func startTCPServer() {
serv := tcp.NewServer(&tcp.ServerConfig{
Name: "hotgo",
Addr: ":8002",
})
// 注册路由
serv.RegisterRouter(
onTestMsg,
)
// 注册RPC路由
serv.RegisterRPCRouter(
onTestRPCMsg,
)
// 服务监听
err := serv.Listen()
gtest.C(T, func(t *gtest.T) {
t.AssertNil(err)
})
}
// 一个基本的消息收发
func TestSendMsg(t *testing.T) {
T = t
go startTCPServer()
ctx := gctx.New()
client := tcp.NewClient(&tcp.ClientConfig{
Addr: "127.0.0.1:8002",
address := freeTCPAddress(t)
messageResponse := make(chan string, 1)
server := tcp.NewServer(&tcp.ServerConfig{Name: "hotgo-test", Addr: address})
server.RegisterRouter(func(ctx context.Context, req *TestMsgReq) {
res := &TestMsgRes{}
res.SetMessage(fmt.Sprintf("你的名字：%s", req.Name))
if err := tcp.ConnFromCtx(ctx).Send(ctx, res); err != nil {
messageResponse <- "send-error:" + err.Error()
}
})
// 注册路由
client.RegisterRouter(
onResponseTestMsg,
)
server.RegisterRPCRouter(func(ctx context.Context, req *TestRPCMsgReq) (*TestRPCMsgRes, error) {
res := &TestRPCMsgRes{}
res.SetMessage(fmt.Sprintf("你的名字：%s", req.Name))
return res, nil
})
serverErrors := make(chan error, 1)
go func() {
err := client.Start()
gtest.C(T, func(t *gtest.T) {
t.AssertNil(err)
})
serverErrors <- server.Listen()
}()
defer server.Close()
// 确保服务都启动完成
time.Sleep(time.Second * 1)
// 拿到客户端的连接
conn := client.Conn()
gtest.C(T, func(t *gtest.T) {
t.AssertNE(conn, nil)
client := tcp.NewClient(&tcp.ClientConfig{
Addr: address,
Timeout: time.Second,
ConnectInterval: 10 * time.Millisecond,
MaxConnectCount: 100,
})
// 向服务器发送tcp消息，不会阻塞程序执行
err := conn.Send(ctx, &TestMsgReq{Name: "Tom"})
gtest.C(T, func(t *gtest.T) {
t.AssertNil(err)
client.RegisterRouter(func(ctx context.Context, res *TestMsgRes) {
messageResponse <- res.Message
})
if err := client.Start(); err != nil {
t.Fatalf("启动TCP客户端失败: %v", err)
}
defer client.Stop()
// 向服务器发送rpc消息，会等待服务器响应结果，直到拿到结果或响应超时才会继续
var res TestRPCMsgRes
if err = conn.RequestScan(ctx, &TestRPCMsgReq{Name: "Tony"}, &res); err != nil {
gtest.C(T, func(t *gtest.T) {
t.AssertNil(err)
})
conn := waitForConnection(t, client, serverErrors)
ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
defer cancel()
if err := conn.Send(ctx, &TestMsgReq{Name: "Tom"}); err != nil {
t.Fatalf("发送TCP消息失败: %v", err)
}
select {
case message := <-messageResponse:
if message != "你的名字：Tom" {
t.Fatalf("TCP响应不符: %s", message)
}
case <-ctx.Done():
t.Fatal("等待TCP响应超时")
}
fmt.Printf("客户端收到RPC消息响应 ==> TestRPCMsgRes:%+v\n", res)
time.Sleep(time.Second * 1)
var rpcResponse TestRPCMsgRes
if err := conn.RequestScan(ctx, &TestRPCMsgReq{Name: "Tony"}, &rpcResponse); err != nil {
t.Fatalf("发送RPC消息失败: %v", err)
}
if rpcResponse.Message != "你的名字：Tony" {
t.Fatalf("RPC响应不符: %s", rpcResponse.Message)
}
}
func freeTCPAddress(t *testing.T) string {
t.Helper()
listener, err := net.Listen("tcp", "127.0.0.1:0")
if err != nil {
t.Fatalf("申请测试端口失败: %v", err)
}
address := listener.Addr().String()
if err = listener.Close(); err != nil {
t.Fatalf("释放测试端口失败: %v", err)
}
return address
}
func waitForConnection(t *testing.T, client *tcp.Client, serverErrors <-chan error) *tcp.Conn {
t.Helper()
deadline := time.NewTimer(2 * time.Second)
defer deadline.Stop()
ticker := time.NewTicker(10 * time.Millisecond)
defer ticker.Stop()
for {
select {
case err := <-serverErrors:
t.Fatalf("TCP服务启动失败: %v", err)
case <-deadline.C:
t.Fatal("等待TCP连接超时")
case <-ticker.C:
if conn := client.Conn(); conn != nil {
return conn
}
}
}
}
server/internal/library/storager/upload_local.go
+44 -10
View File
@@ -13,6 +13,7 @@ import (
"github.com/gogf/gf/v2/os/gfile"
"github.com/gogf/gf/v2/os/gtime"
"github.com/gogf/gf/v2/util/gconv"
"io"
"os"
"path/filepath"
"sort"
@@ -137,20 +138,53 @@ func (d *LocalDrive) UploadPart(ctx context.Context, in *UploadPartParams) (res
// MergePartFile 合并分片文件
func MergePartFile(srcPath, dstPath string) (err error) {
dir, err := os.ReadDir(srcPath)
entries, err := os.ReadDir(srcPath)
if err != nil {
return err
}
sort.Slice(dir, func(i, j int) bool {
fiIndex, _ := strconv.Atoi(dir[i].Name())
fjIndex, _ := strconv.Atoi(dir[j].Name())
return fiIndex < fjIndex
type filePart struct {
index int
path string
}
parts := make([]filePart, 0, len(entries))
for _, entry := range entries {
if entry.IsDir() {
continue
}
index, parseErr := strconv.Atoi(entry.Name())
if parseErr != nil || index <= 0 {
return gerror.Newf("无效的分片文件名：%s", entry.Name())
}
parts = append(parts, filePart{index: index, path: filepath.Join(srcPath, entry.Name())})
}
if len(parts) == 0 {
return gerror.New("没有可合并的分片文件")
}
sort.Slice(parts, func(i, j int) bool {
return parts[i].index < parts[j].index
})
for _, file := range dir {
filePath := filepath.Join(srcPath, file.Name())
if err = gfile.PutBytesAppend(dstPath, gfile.GetBytes(filePath)); err != nil {
return err
if err = os.MkdirAll(filepath.Dir(dstPath), 0o755); err != nil {
return gerror.Wrap(err, "创建目标目录失败")
}
dstFile, err := os.OpenFile(dstPath, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, 0o644)
if err != nil {
return gerror.Wrap(err, "创建合并文件失败")
}
defer dstFile.Close()
for _, part := range parts {
srcFile, openErr := os.Open(part.path)
if openErr != nil {
return gerror.Wrapf(openErr, "打开分片%d失败", part.index)
}
_, copyErr := io.Copy(dstFile, srcFile)
closeErr := srcFile.Close()
if copyErr != nil {
return gerror.Wrapf(copyErr, "合并分片%d失败", part.index)
}
if closeErr != nil {
return gerror.Wrapf(closeErr, "关闭分片%d失败", part.index)
}
}
return
return dstFile.Sync()
}
server/internal/library/storager/upload_local_test.go
+33 -42
View File
@@ -1,61 +1,52 @@
package storager
import (
"crypto/md5"
"errors"
"fmt"
"io"
"bytes"
"os"
"path/filepath"
"testing"
)
func TestMergePartFile(t *testing.T) {
srcFile, _ := os.Open("1.zip")
defer srcFile.Close()
fileInfo, err := srcFile.Stat()
if err != nil {
t.Error(err)
tempDir := t.TempDir()
partDir := filepath.Join(tempDir, "parts")
if err := os.MkdirAll(partDir, 0o755); err != nil {
t.Fatal(err)
}
hash := md5.New()
_, err = io.Copy(hash, srcFile)
sum := hash.Sum(nil)
fileHash := fmt.Sprintf("%x", sum)
var singleSize = int64(1024 * 1024 * 100)
chunks := int(fileInfo.Size() / singleSize)
if fileInfo.Size()%singleSize != 0 {
chunks += 1
parts := map[string][]byte{
"1": []byte("first-"),
"2": []byte("second-"),
"10": []byte("tenth"),
}
srcFile.Seek(0, io.SeekStart)
for j := 0; j < chunks; j++ {
partSize := singleSize
if j == chunks-1 {
partSize = fileInfo.Size() - int64(j)*singleSize
for name, content := range parts {
if err := os.WriteFile(filepath.Join(partDir, name), content, 0o644); err != nil {
t.Fatal(err)
}
partData := make([]byte, partSize)
_, err = io.ReadFull(srcFile, partData)
pf, _ := os.Create(fmt.Sprintf("tmp/%d", j+1))
_, err = pf.Write(partData)
if err != nil {
t.Error(err)
return
}
pf.Close()
}
err = MergePartFile("tmp/", "2.zip")
destination := filepath.Join(tempDir, "merged.bin")
if err := os.WriteFile(destination, []byte("stale-data"), 0o644); err != nil {
t.Fatal(err)
}
if err := MergePartFile(partDir, destination); err != nil {
t.Fatalf("合并分片失败: %v", err)
}
actual, err := os.ReadFile(destination)
if err != nil {
t.Error(err)
return
t.Fatal(err)
}
expected := []byte("first-second-tenth")
if !bytes.Equal(actual, expected) {
t.Fatalf("合并内容不符 expected=%q actual=%q", expected, actual)
}
}
f2, _ := os.Open("2.zip")
hash2 := md5.New()
_, err = io.Copy(hash2, f2)
sum2 := hash.Sum(nil)
fileHash2 := fmt.Sprintf("%x", sum2)
if fileHash != fileHash2 {
t.Error(errors.New("hash mismatch"))
func TestMergePartFileRejectsEmptyDirectory(t *testing.T) {
partDir := t.TempDir()
err := MergePartFile(partDir, filepath.Join(t.TempDir(), "merged.bin"))
if err == nil {
t.Fatal("空分片目录应返回错误")
}
}