feat 初次提交

internal/handler/http_handler/login.go

@@ -0,0 +1,118 @@
+package http_handler
+
+import (
+	"common/db/redis"
+	"common/log"
+	"common/net/grpc/service"
+	"common/net/http/http_resp"
+	"common/proto/ss/grpc_pb"
+	"common/utils"
+	"context"
+	"fmt"
+	"gateway/config"
+	"github.com/gin-gonic/gin"
+	"time"
+)
+
+// 这个模块处理用户登录
+
+type LoginReq struct {
+	Phone string `json:"phone" binding:"required,min=1"`
+	Code  string `json:"code" binding:"required,min=1"`
+}
+
+type LoginResp struct {
+	USN          int64  `json:"usn"`
+	Name         string `json:"name"`
+	AccessToken  string `json:"accessToken"`
+	RefreshToken string `json:"refreshToken"`
+}
+
+func Login(c *gin.Context) {
+	req := &LoginReq{}
+	if err := c.ShouldBindJSON(req); err != nil {
+		http_resp.JsonBadRequest(c)
+		return
+	}
+	client, err := service.UserNewClientLB()
+	if err != nil {
+		log.Errorf("Login UserNewClientLB error: %v", err)
+		http_resp.JsonOK(c, http_resp.Error(http_resp.Failed))
+		return
+	}
+	login, err := client.Login(c, &grpc_pb.LoginReq{
+		Phone: req.Phone,
+		Code:  req.Code,
+	})
+	if err != nil {
+		log.Errorf("Login Login error: %v", err)
+		http_resp.JsonOK(c, http_resp.Error(http_resp.Failed))
+		return
+	}
+
+	at, rt, err := genToken(c, login.USN)
+	http_resp.JsonOK(c, http_resp.Success(&LoginResp{
+		USN:          login.USN,
+		Name:         login.Name,
+		AccessToken:  at,
+		RefreshToken: rt,
+	}))
+}
+
+type RefreshTokenReq struct {
+	RefreshToken string `json:"refreshToken" binding:"required,min=1"`
+}
+
+type RefreshTokenResp struct {
+	AccessToken  string `json:"accessToken"`
+	RefreshToken string `json:"refreshToken"`
+}
+
+func RefreshToken(c *gin.Context) {
+	req := &RefreshTokenReq{}
+	if err := c.ShouldBindJSON(req); err != nil {
+		http_resp.JsonBadRequest(c)
+		return
+	}
+	claims, err := utils.ParseToken(req.RefreshToken, config.Get().Auth.Secret)
+	if err != nil {
+		http_resp.JsonOK(c, http_resp.Error(http_resp.TokenInvalid))
+		return
+	}
+	if redis.GetClient().Get(c, fmt.Sprintf(config.KeyUserRefreshToken, claims.USN)).String() != req.RefreshToken {
+		http_resp.JsonOK(c, http_resp.Error(http_resp.TokenInvalid))
+		return
+	}
+	at, rt, err := genToken(c, claims.USN)
+	if err != nil {
+		log.Errorf("RefreshToken genToken error: %v, usn: %v", err, claims.USN)
+		http_resp.JsonOK(c, http_resp.Error(http_resp.Failed))
+		return
+	}
+
+	http_resp.JsonOK(c, http_resp.Success(&RefreshTokenResp{
+		AccessToken:  at,
+		RefreshToken: rt,
+	}))
+}
+
+func genToken(ctx context.Context, usn int64) (string, string, error) {
+	at, err := genTokenOne(ctx, config.KeyUserAccessToken, usn, 2*time.Hour)
+	if err != nil {
+		return "", "", err
+	}
+	rt, err := genTokenOne(ctx, config.KeyUserRefreshToken, usn, 3*24*time.Hour)
+	if err != nil {
+		return "", "", err
+	}
+	return at, rt, nil
+}
+
+func genTokenOne(ctx context.Context, key string, usn int64, ttl time.Duration) (string, error) {
+	token, err := utils.GenToken(usn, config.Get().Auth.Secret, time.Duration(config.Get().Auth.Expire)*time.Second)
+	if err != nil {
+		return "", err
+	}
+	redis.GetClient().Set(ctx, fmt.Sprintf(key, usn), token, ttl)
+	return token, err
+}

internal/handler/http_handler/test.go

@@ -0,0 +1,27 @@
+package http_handler
+
+import (
+	"common/net/http/http_resp"
+	"github.com/gin-gonic/gin"
+)
+
+// 这个模块处理用户登录
+
+type TestReq struct {
+}
+
+type TestResp struct {
+	Info string `json:"info"`
+}
+
+func Test(c *gin.Context) {
+	req := &TestReq{}
+	if err := c.ShouldBindJSON(req); err != nil {
+		http_resp.JsonBadRequest(c)
+		return
+	}
+
+	http_resp.JsonOK(c, http_resp.Success(&TestResp{
+		Info: "成功了",
+	}))
+}

internal/handler/ws_handler/client.go

@@ -0,0 +1,106 @@
+package ws_handler
+
+import (
+	"common/log"
+	"common/net/socket"
+	"context"
+	"fmt"
+	"go.uber.org/zap"
+	"runtime/debug"
+	"sync"
+	"time"
+)
+
+var GatewaySID int64
+
+type Client struct {
+	sync.WaitGroup
+	conn      socket.ISocketConn // Socket
+	mailChan  chan Event         // 邮箱队列
+	logger    *zap.SugaredLogger // 日志
+	ctx       context.Context    // 上下文
+	cancel    context.CancelFunc // 取消上下文
+	heartBeat time.Time          // 最后一次心跳
+
+	USN        int64 // 用户ID
+	SceneSID   int64 // 场景服ID
+	InstanceID int32 // 副本ID，副本类型
+	UniqueNo   int64 // 副本唯一编号
+}
+
+func NewClient(usn int64, conn socket.ISocketConn) *Client {
+	client := &Client{
+		USN:       usn,
+		conn:      conn,
+		logger:    log.GetLogger().Named(fmt.Sprintf("usn:%v", usn)),
+		heartBeat: time.Now(),
+		mailChan:  make(chan Event, 1024),
+	}
+	client.ctx, client.cancel = context.WithCancel(context.Background())
+	client.Add(1)
+	go client.Loop()
+	return client
+}
+
+func (c *Client) Loop() {
+	defer func() {
+		if err := recover(); err != nil {
+			c.logger.Errorf("Client Loop err: %v", err)
+			debug.PrintStack()
+		}
+	}()
+	defer c.onClose()
+	t := time.NewTicker(20 * time.Second)
+	defer t.Stop()
+	for {
+		select {
+		case <-c.ctx.Done():
+			return
+		case evt, ok := <-c.mailChan:
+			if ok {
+				c.handle(evt)
+			}
+		case <-t.C:
+			_ = c.conn.Ping()
+			if time.Now().Sub(c.heartBeat) > 60*time.Second {
+				return
+			}
+		}
+	}
+}
+
+func (c *Client) OnEvent(event Event) {
+	defer func() {
+		if err := recover(); err != nil {
+			c.logger.Warnf(fmt.Sprintf("send event chan error: %v", err))
+		}
+	}()
+	select {
+	case c.mailChan <- event:
+	default:
+		c.logger.Warnf("Client mailChan full")
+	}
+}
+
+// CloseClient 关闭客户端（同步，会等待onClose执行完成）
+func (c *Client) CloseClient() {
+	if c.cancel != nil {
+		c.cancel()
+		c.Wait()
+	}
+}
+
+// onClose 客户端关闭自动触发
+func (c *Client) onClose() {
+	if c.conn != nil {
+		_ = c.conn.Close()
+		c.conn = nil
+	}
+	if c.mailChan != nil {
+		close(c.mailChan)
+		c.mailChan = nil
+	}
+	UserMgr.Delete(c.USN)
+	c.onLeave()
+	c.Done()
+}

internal/handler/ws_handler/client_write.go

@@ -0,0 +1,57 @@
+package ws_handler
+
+import (
+	"common/proto/sc/sc_pb"
+	"google.golang.org/protobuf/proto"
+)
+
+// WriteMessage 向客户端发送消息
+func (c *Client) WriteMessage(id sc_pb.MessageID, data proto.Message) {
+	if c.conn == nil || c.conn.IsClose() {
+		return
+	}
+	d, err := proto.Marshal(data)
+	if err != nil {
+		c.logger.Errorf("WriteMessage proto.Marshal err: %v", err)
+		return
+	}
+	m, err := proto.Marshal(&sc_pb.Message{
+		ID:      id,
+		Payload: d,
+	})
+	if err != nil {
+		c.logger.Errorf("WriteMessage proto.Marshal err: %v", err)
+		return
+	}
+	if err = c.conn.Write(m); err != nil {
+		c.logger.Errorf("WriteMessage err: %v", err)
+	}
+}
+
+// WriteBytes 向客户端发送字节数据
+func (c *Client) WriteBytes(id sc_pb.MessageID, data []byte) {
+	if c.conn == nil || c.conn.IsClose() {
+		return
+	}
+	m, err := proto.Marshal(&sc_pb.Message{
+		ID:      id,
+		Payload: data,
+	})
+	if err != nil {
+		c.logger.Errorf("WriteBytes proto.Marshal err: %v", err)
+		return
+	}
+	if err = c.conn.Write(m); err != nil {
+		c.logger.Errorf("WriteBytes err: %v", err)
+	}
+}
+
+// WriteBytesPreMarshal 向客户端发送字节数据（需要预先打包，适合广播相同数据）
+func (c *Client) WriteBytesPreMarshal(data []byte) {
+	if c.conn == nil || c.conn.IsClose() {
+		return
+	}
+	if err := c.conn.Write(data); err != nil {
+		c.logger.Errorf("WriteBytes err: %v", err)
+	}
+}

internal/handler/ws_handler/event.go

@@ -0,0 +1,13 @@
+package ws_handler
+
+type Event interface {
+}
+
+type ClientEvent struct {
+	Event
+	Msg []byte
+}
+
+type PongEvent struct {
+	Event
+}

internal/handler/ws_handler/handler.go

@@ -0,0 +1,97 @@
+package ws_handler
+
+import (
+	"common/net/grpc/service"
+	"common/proto/sc/sc_pb"
+	"common/proto/ss/grpc_pb"
+	"gateway/internal/grpc_server/stream_client"
+	"google.golang.org/protobuf/proto"
+	"time"
+)
+
+func (c *Client) handle(event Event) {
+	switch e := event.(type) {
+	case *ClientEvent:
+		msg := &sc_pb.Message{}
+		if err := proto.Unmarshal(e.Msg, msg); err != nil {
+			c.logger.Errorf("handle event proto.Unmarshal err: %v", err)
+			c.cancel()
+			return
+		}
+		switch msg.ID {
+		case sc_pb.MessageID_MESSAGE_ID_ENTER_INSTANCE:
+			m := &sc_pb.C2S_EnterInstance{}
+			if err := proto.Unmarshal(msg.Payload, m); err != nil {
+				c.logger.Errorf("handle event proto.Unmarshal err: %v", err)
+				c.cancel()
+				return
+			}
+			c.onEnter(m)
+		case sc_pb.MessageID_MESSAGE_ID_ACTION:
+			m := &sc_pb.C2S_Action{}
+			if err := proto.Unmarshal(msg.Payload, m); err != nil {
+				c.logger.Errorf("handle event proto.Unmarshal err: %v", err)
+				c.cancel()
+				return
+			}
+			c.onAction(m)
+		}
+	case *PongEvent:
+		c.heartBeat = time.Now()
+	}
+}
+
+func (c *Client) onEnter(msg *sc_pb.C2S_EnterInstance) {
+	client, err := service.SceneNewClientLB()
+	if err != nil {
+		c.logger.Errorf("SceneNewClient err: %v", err)
+		return
+	}
+	resp, err := client.Enter(c.ctx, &grpc_pb.EnterReq{
+		USN:        c.USN,
+		GatewaySID: GatewaySID,
+		InstanceID: msg.InstanceID,
+	})
+	if err != nil {
+		c.logger.Errorf("enter err: %v", err)
+		return
+	}
+	c.SceneSID = resp.SceneSID
+	c.UniqueNo = resp.UniqueNo
+	c.InstanceID = msg.InstanceID
+	c.WriteBytes(sc_pb.MessageID(resp.MessageID), resp.Payload)
+}
+
+func (c *Client) onLeave() {
+	client, err := service.SceneNewClient(c.SceneSID)
+	if err != nil {
+		c.logger.Errorf("SceneNewClient err: %v", err)
+		return
+	}
+	_, err = client.Leave(c.ctx, &grpc_pb.LeaveReq{
+		USN:        c.USN,
+		GatewaySID: GatewaySID,
+		InstanceID: c.InstanceID,
+		UniqueNo:   c.UniqueNo,
+	})
+	if err != nil {
+		c.logger.Errorf("leave err: %v", err)
+		return
+	}
+}
+
+func (c *Client) onAction(msg *sc_pb.C2S_Action) {
+	if c.SceneSID == 0 {
+		return
+	}
+	if err := stream_client.SendMessageToScene(c.SceneSID, stream_client.FunAction, &grpc_pb.ActionReq{
+		UniqueNo: c.UniqueNo,
+		USN:      c.USN,
+		Action:   int32(msg.Action),
+		DirX:     msg.DirX,
+		DirY:     msg.DirY,
+		SkillID:  msg.SkillID,
+	}); err != nil {
+		c.logger.Errorf("send action err: %v", err)
+	}
+}

internal/handler/ws_handler/manager.go

@@ -0,0 +1,58 @@
+package ws_handler
+
+import (
+	"sync"
+)
+
+var UserMgr *userManager
+
+type userManager struct {
+	userMap map[int64]*Client
+	sync.RWMutex
+}
+
+func init() {
+	UserMgr = &userManager{
+		userMap: make(map[int64]*Client),
+	}
+}
+
+func (m *userManager) Add(usn int64, client *Client) {
+	m.Lock()
+	defer m.Unlock()
+	m.userMap[usn] = client
+}
+
+func (m *userManager) Delete(usn int64) {
+	m.Lock()
+	defer m.Unlock()
+	delete(m.userMap, usn)
+}
+
+func (m *userManager) GetAll() map[int64]*Client {
+	m.RLock()
+	defer m.RUnlock()
+
+	copyMap := make(map[int64]*Client, len(m.userMap))
+	for k, v := range m.userMap {
+		copyMap[k] = v
+	}
+	return copyMap
+}
+
+func (m *userManager) GetAllInterface() []interface{} {
+	m.RLock()
+	defer m.RUnlock()
+
+	r := make([]interface{}, 0)
+	for _, v := range m.userMap {
+		r = append(r, v)
+	}
+	return r
+}
+
+func (m *userManager) GetByUSN(usn int64) *Client {
+	m.RLock()
+	defer m.RUnlock()
+	return m.userMap[usn]
+}