first commit

main/chatserver.go

@@ -0,0 +1,28 @@
+package main
+
+import (
+	"log/slog"
+	"os"
+	"slgserver/config"
+	"slgserver/net"
+	"slgserver/server/chatserver"
+)
+
+func getChatServerAddr() string {
+	host := config.GetString("chatserver.host", "")
+	port := config.GetString("chatserver.port", "8002")
+	return host + ":" + port
+}
+
+func main() {
+	if wd, err := os.Getwd(); err == nil {
+		slog.Info("working directory", "dir", wd)
+	} else {
+		slog.Warn("get working directory failed", "error", err)
+	}
+	chatserver.Init()
+	needSecret := config.GetBool("chatserver.need_secret", false)
+	s := net.NewServer(getChatServerAddr(), needSecret)
+	s.Router(chatserver.MyRouter)
+	s.Start()
+}

main/gateserver.go

@@ -0,0 +1,30 @@
+package main
+
+import (
+	"log/slog"
+	"os"
+	"slgserver/config"
+	"slgserver/net"
+	"slgserver/server/gateserver"
+	"slgserver/server/gateserver/controller"
+)
+
+func getGateServerAddr() string {
+	host := config.GetString("gateserver.host", "")
+	port := config.GetString("gateserver.port", "8004")
+	return host + ":" + port
+}
+
+func main() {
+	if wd, err := os.Getwd(); err == nil {
+		slog.Info("working directory", "dir", wd)
+	} else {
+		slog.Warn("get working directory failed", "error", err)
+	}
+	gateserver.Init()
+	needSecret := config.GetBool("gateserver.need_secret", false)
+	s := net.NewServer(getGateServerAddr(), needSecret)
+	s.Router(gateserver.MyRouter)
+	s.SetOnBeforeClose(controller.GHandle.OnServerConnClose)
+	s.Start()
+}

main/httpserver.go

@@ -0,0 +1,29 @@
+package main
+
+import (
+	"github.com/gin-gonic/gin"
+	"slgserver/config"
+	"slgserver/db"
+	"slgserver/server/httpserver/controller"
+)
+
+func main() {
+	// 设置 Gin 为 release 模式
+	gin.SetMode(gin.ReleaseMode)
+
+	db.TestDB()
+
+	r := gin.Default()
+
+	g := r.Group("")
+	new(controller.AccountController).RegisterRoutes(g)
+	
+	addr := getHttpAddr()
+	r.Run(addr)
+}
+
+func getHttpAddr() string {
+	host := config.GetString("httpserver.host", "")
+	port := config.GetString("httpserver.port", "8088")
+	return host + ":" + port
+}

main/loginserver.go

@@ -0,0 +1,28 @@
+package main
+
+import (
+	"log/slog"
+	"os"
+	"slgserver/config"
+	"slgserver/net"
+	"slgserver/server/loginserver"
+)
+
+func getLoginServerAddr() string {
+	host := config.GetString("loginserver.host", "")
+	port := config.GetString("loginserver.port", "8003")
+	return host + ":" + port
+}
+
+func main() {
+	if wd, err := os.Getwd(); err == nil {
+		slog.Info("working directory", "dir", wd)
+	} else {
+		slog.Warn("get working directory failed", "error", err)
+	}
+	loginserver.Init()
+	needSecret := config.GetBool("loginserver.need_secret", false)
+	s := net.NewServer(getLoginServerAddr(), needSecret)
+	s.Router(loginserver.MyRouter)
+	s.Start()
+}

main/slgserver.go

@@ -0,0 +1,28 @@
+package main
+
+import (
+	"log/slog"
+	"os"
+	"slgserver/config"
+	"slgserver/net"
+	"slgserver/server/slgserver/run"
+)
+
+func getServerAddr() string {
+	host := config.GetString("slgserver.host", "")
+	port := config.GetString("slgserver.port", "8001")
+	return host + ":" + port
+}
+
+func main() {
+	if wd, err := os.Getwd(); err == nil {
+		slog.Info("working directory", "dir", wd)
+	} else {
+		slog.Warn("get working directory failed", "error", err)
+	}
+	run.Init()
+	needSecret := config.GetBool("slgserver.need_secret", false)
+	s := net.NewServer(getServerAddr(), needSecret)
+	s.Router(run.MyRouter)
+	s.Start()
+}

main/wstest.go

@@ -0,0 +1,125 @@
+package main
+
+import (
+	"github.com/go-think/openssl"
+	"github.com/mitchellh/mapstructure"
+	"github.com/gorilla/websocket"
+	"log/slog"
+	"slgserver/net"
+	proto2 "slgserver/server/loginserver/proto"
+	"slgserver/util"
+	"time"
+)
+
+var origin = "httpserver://127.0.0.1:8002/"
+var secretKey = []byte("")
+var session = ""
+
+func main() {
+
+	var dialer *websocket.Dialer
+	//通过Dialer连接websocket服务器
+	conn, _, err := dialer.Dial("ws://127.0.0.1:8001", nil)
+	if err != nil {
+		slog.Error("dial websocket failed", "error", err)
+		return
+	}
+
+	go do(conn)
+	go timeWriter(conn)
+
+	time.Sleep(10 * time.Second)
+}
+
+func do(conn *websocket.Conn) {
+	defer func() {
+		if err := recover(); err != nil {
+			slog.Error("do panic", "error", err)
+		}
+	}()
+
+	for {
+		_, message, _ := conn.ReadMessage()
+		msg := &net.RspBody{}
+		if len(secretKey) == 0 {
+			message, _ = util.UnZip(message)
+			if err := util.Unmarshal(message, msg); err == nil {
+				if msg.Name == "handshake" {
+					h := &net.Handshake{}
+					mapstructure.Decode(msg.Msg, h)
+
+					secretKey = []byte(h.Key)
+				}
+				slog.Info("received message", "name", msg.Name)
+			}
+		} else {
+			message, _ = util.UnZip(message)
+			data, err := util.AesCBCDecrypt(message, secretKey, secretKey, openssl.ZEROS_PADDING)
+			if err == nil {
+				if err := util.Unmarshal(data, msg); err == nil {
+					slog.Info("received message",
+						"name", msg.Name,
+						"code", msg.Code,
+						"payload", msg.Msg)
+					if msg.Name == "login" {
+						lr := &proto2.LoginRsp{}
+						mapstructure.Decode(msg.Msg, lr)
+						session = lr.Session
+					}
+				} else {
+					secretKey = []byte("")
+				}
+			} else {
+				secretKey = []byte("")
+			}
+		}
+	}
+}
+
+func login(conn *websocket.Conn) {
+	l := &proto2.LoginReq{Ip: "127.0.0.1", Username: "test", Password: "123456"}
+	send(conn, "login", l)
+}
+
+func reLogin(conn *websocket.Conn, session string) {
+	l := &proto2.ReLoginReq{Session: session}
+	slog.Info("relogin session", "session", session)
+	send(conn, "reLogin", l)
+}
+
+func logout(conn *websocket.Conn) {
+	l := &proto2.LogoutReq{UId: 5}
+	send(conn, "logout", l)
+}
+
+func send(conn *websocket.Conn, name string, dd interface{}) {
+	msg := &net.ReqBody{Name: name, Msg: dd}
+
+	if len(secretKey) == 0 {
+
+	} else {
+		if data, err := util.Marshal(msg); err == nil {
+			data, _ := util.AesCBCEncrypt(data, secretKey, secretKey, openssl.ZEROS_PADDING)
+			data, _ = util.Zip(data)
+
+			conn.WriteMessage(websocket.BinaryMessage, data)
+		}
+	}
+}
+
+func timeWriter(conn *websocket.Conn) {
+
+	time.Sleep(time.Second * 1)
+	login(conn)
+
+	time.Sleep(time.Second * 1)
+	reLogin(conn, session)
+
+	time.Sleep(20 * time.Second)
+
+	//time.Sleep(time.Second * 1)
+	//reLogin(conn, "123")
+	//
+	//time.Sleep(time.Second * 1)
+	//logout(conn)
+}