feat 初次提交

internal/net/http_gateway/middleward.go

@@ -0,0 +1,78 @@
+package http_gateway
+
+import (
+	"common/net/http/http_resp"
+	"common/utils"
+	"fmt"
+	"gateway/config"
+	"github.com/gin-contrib/cors"
+	"github.com/gin-gonic/gin"
+	"go.uber.org/zap"
+	"strconv"
+	"strings"
+	"time"
+)
+
+func corsConfig() cors.Config {
+	return cors.Config{
+		AllowMethods:     []string{"GET", "POST", "OPTIONS"},
+		AllowHeaders:     []string{"Content-Type", "Authorization"},
+		AllowCredentials: false,
+		AllowAllOrigins:  true,
+		MaxAge:           12 * time.Hour,
+	}
+}
+
+func ginLogger(logger *zap.SugaredLogger) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		start := time.Now()
+		path := c.Request.URL.Path
+		c.Next()
+		cost := time.Since(start)
+
+		logger.Infof(fmt.Sprintf(
+			"HTTP Method:%v Code:%v Time:%v IP:%v Path:%v",
+			c.Request.Method,
+			c.Writer.Status(),
+			cost,
+			c.ClientIP(),
+			path),
+		)
+	}
+}
+
+func authJwt() gin.HandlerFunc {
+	return func(c *gin.Context) {
+		// 如果是Public接口，有Token就读，没有就算了
+		public := false
+		for _, path := range config.PublicPaths {
+			if strings.HasPrefix(c.Request.URL.Path, path) {
+				public = true
+				break
+			}
+		}
+
+		token := strings.TrimPrefix(c.GetHeader("Authorization"), "Bearer ")
+		if token == "" {
+			if public {
+				c.Next()
+				return
+			}
+			http_resp.AbortUnauthorized(c)
+			return
+		}
+		claims, err := utils.ParseToken(token, config.Get().Auth.Secret)
+		if err != nil {
+			if public {
+				c.Next()
+				return
+			}
+			http_resp.AbortUnauthorized(c)
+			return
+		}
+
+		// 这里将Header写到请求中，grpc-gateway框架会读取然后传给grpc服务
+		c.Request.Header.Set("X-Usn", strconv.Itoa(int(claims.USN)))
+		c.Next()
+	}
+}

internal/net/http_gateway/router.go

@@ -0,0 +1,93 @@
+package http_gateway
+
+import (
+	"common/log"
+	"common/net/grpc/service"
+	"common/net/http/http_resp"
+	"common/proto/ss/grpc_pb"
+	"context"
+	"gateway/internal/handler/http_handler"
+	"gateway/internal/net/http_gateway/wrapper"
+	"github.com/gin-contrib/cors"
+	"github.com/gin-gonic/gin"
+	"github.com/grpc-ecosystem/grpc-gateway/v2/runtime"
+	"google.golang.org/protobuf/encoding/protojson"
+)
+
+func InitServeMux() *runtime.ServeMux {
+	baseMarshaler := &runtime.JSONPb{
+		MarshalOptions: protojson.MarshalOptions{
+			UseProtoNames:   false,
+			EmitUnpopulated: true,
+		},
+		UnmarshalOptions: protojson.UnmarshalOptions{
+			DiscardUnknown: true,
+		},
+	}
+	unifiedMarshaler := wrapper.NewWrappedMarshaler(baseMarshaler)
+
+	mux := runtime.NewServeMux(
+		runtime.WithMarshalerOption(runtime.MIMEWildcard, unifiedMarshaler),
+		runtime.WithErrorHandler(wrapper.ErrorHandler),
+		runtime.WithIncomingHeaderMatcher(func(header string) (string, bool) {
+			if header == "X-Usn" {
+				return "X-Usn", true
+			}
+			return runtime.DefaultHeaderMatcher(header)
+		}),
+	)
+	return mux
+}
+
+func InitRouter() *gin.Engine {
+	gin.SetMode(gin.ReleaseMode)
+
+	r := gin.New()
+	r.Use(
+		gin.Recovery(),
+		ginLogger(log.GetLogger().Named("GIN")),
+		cors.New(corsConfig()),
+	)
+
+	r.HandleMethodNotAllowed = true
+	r.NoMethod(func(c *gin.Context) {
+		http_resp.JsonMethodNotAllowed(c)
+	})
+	r.NoRoute(func(c *gin.Context) {
+		http_resp.JsonNotFound(c)
+	})
+
+	initBaseRoute(r.Group("/"))
+
+	auth := r.Group("/")
+	auth.Use(authJwt())
+
+	// 用户中心
+	initUserPath(auth)
+
+	return r
+}
+
+func initBaseRoute(r *gin.RouterGroup) {
+	g := r.Group("/gw")
+	g.POST("/login", http_handler.Login)
+	g.POST("/refresh_token", http_handler.RefreshToken)
+	g.GET("/test", http_handler.Test)
+}
+
+func initUserPath(r *gin.RouterGroup) {
+	g := r.Group("/user")
+	client, err := service.UserNewClientLB()
+	if err != nil {
+		log.Errorf("get user conn failed: %v", err)
+		return
+	}
+
+	gwMux := InitServeMux()
+	if err = grpc_pb.RegisterUserHandlerClient(context.Background(), gwMux, client); err != nil {
+		log.Errorf("RegisterUserHandlerClient err: %v", err)
+		return
+	}
+
+	g.Any("/*path", gin.WrapH(gwMux))
+}

internal/net/http_gateway/wrapper/error_handler.go

@@ -0,0 +1,57 @@
+package wrapper
+
+import (
+	"common/net/http/http_resp"
+	"common/proto/ss/ss_common"
+	"context"
+	"encoding/json"
+	"github.com/grpc-ecosystem/grpc-gateway/v2/runtime"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
+	"net/http"
+)
+
+// ErrorHandler 将 gRPC 错误转为统一 JSON 格式
+func ErrorHandler(_ context.Context, _ *runtime.ServeMux, _ runtime.Marshaler, w http.ResponseWriter, _ *http.Request, err error) {
+	st, ok := status.FromError(err)
+	if !ok {
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(http.StatusInternalServerError)
+		_ = json.NewEncoder(w).Encode(http_resp.Error(http_resp.Failed))
+		return
+	}
+
+	code, msg := 0, ""
+	for _, detail := range st.Details() {
+		if errorInfo, ok := detail.(*ss_common.ErrorInfo); ok {
+			code = int(errorInfo.Code)
+			msg = errorInfo.Msg
+			break
+		}
+	}
+	if code == 0 {
+		code = http_resp.Failed.Code()
+		msg = http_resp.Failed.Error()
+	}
+	if st.Code() == codes.Unknown ||
+		st.Code() == codes.Unimplemented ||
+		st.Code() == codes.NotFound {
+		msg = st.Message()
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(grpcCodeToHTTPCode(st.Code()))
+	_ = json.NewEncoder(w).Encode(http_resp.Error(http_resp.NewCode(code, msg)))
+}
+
+// 这里定义 Internal 属于业务错误，其他的属于 500 报错
+func grpcCodeToHTTPCode(c codes.Code) int {
+	switch c {
+	case codes.OK, codes.Unknown:
+		return http.StatusOK
+	case codes.Unimplemented, codes.NotFound:
+		return http.StatusNotFound
+	default:
+		return http.StatusInternalServerError
+	}
+}

internal/net/http_gateway/wrapper/marshal.go

@@ -0,0 +1,42 @@
+package wrapper
+
+import (
+	"common/net/http/http_resp"
+	"encoding/json"
+	"github.com/grpc-ecosystem/grpc-gateway/v2/runtime"
+	"io"
+)
+
+// WrappedMarshaler 自动包装响应为 { code, message, data }
+type WrappedMarshaler struct {
+	inner runtime.Marshaler
+}
+
+func NewWrappedMarshaler(inner runtime.Marshaler) *WrappedMarshaler {
+	return &WrappedMarshaler{inner: inner}
+}
+
+// Marshal 将 gRPC 响应包装成统一格式
+func (w *WrappedMarshaler) Marshal(v interface{}) ([]byte, error) {
+	dataBytes, err := w.inner.Marshal(v)
+	if err != nil {
+		return json.Marshal(http_resp.Error(http_resp.Failed))
+	}
+	return json.Marshal(http_resp.Success(json.RawMessage(dataBytes)))
+}
+
+func (w *WrappedMarshaler) Unmarshal(data []byte, v interface{}) error {
+	return w.inner.Unmarshal(data, v)
+}
+
+func (w *WrappedMarshaler) NewDecoder(r io.Reader) runtime.Decoder {
+	return w.inner.NewDecoder(r)
+}
+
+func (w *WrappedMarshaler) NewEncoder(wr io.Writer) runtime.Encoder {
+	return w.inner.NewEncoder(wr)
+}
+
+func (w *WrappedMarshaler) ContentType(v interface{}) string {
+	return "application/json"
+}

internal/net/ws_gateway/server.go

@@ -0,0 +1,74 @@
+package ws_gateway
+
+import (
+	"common/log"
+	"common/net/socket"
+	"common/utils"
+	"fmt"
+	"gateway/internal/handler/ws_handler"
+	"go.uber.org/zap"
+	"strconv"
+	"time"
+)
+
+type GatewayWsServer struct {
+	logger *zap.SugaredLogger
+}
+
+func (g *GatewayWsServer) OnOpen(conn socket.ISocketConn) ([]byte, socket.Action) {
+	g.logger = log.GetLogger().Named(fmt.Sprintf("addr:%v", conn.RemoteAddr()))
+	return nil, socket.None
+}
+
+func (g *GatewayWsServer) OnHandShake(conn socket.ISocketConn, bytes []byte, callback func(conn socket.ISocketConn, bytes []byte)) socket.Action {
+	token, ok := conn.GetParam("token").(string)
+	if !ok {
+		g.logger.Warnf("token is not string")
+		return socket.Close
+	}
+	//claims, err := utils.ParseToken(token, config.Get().Auth.Secret)
+	//if err != nil {
+	//	g.logger.Warnf("token is invalid")
+	//	return socket.Close
+	//}
+
+	t, _ := strconv.Atoi(token)
+	claims := utils.Claims{
+		USN: int64(t),
+	}
+	go func(shResp []byte) {
+		if oldClient := ws_handler.UserMgr.GetByUSN(claims.USN); oldClient != nil {
+			oldClient.CloseClient()
+		}
+		client := ws_handler.NewClient(claims.USN, conn)
+		ws_handler.UserMgr.Add(claims.USN, client)
+		conn.SetParam("client", client)
+		callback(conn, shResp)
+	}(bytes)
+	return socket.None
+}
+
+func (g *GatewayWsServer) OnMessage(conn socket.ISocketConn, bytes []byte) socket.Action {
+	client, ok := conn.GetParam("client").(*ws_handler.Client)
+	if !ok || client.USN == 0 {
+		return socket.Close
+	}
+	client.OnEvent(&ws_handler.ClientEvent{Msg: bytes})
+	return socket.None
+}
+
+func (g *GatewayWsServer) OnPong(conn socket.ISocketConn) {
+	client, ok := conn.GetParam("client").(*ws_handler.Client)
+	if !ok || client.USN == 0 {
+		return
+	}
+	client.OnEvent(&ws_handler.PongEvent{})
+}
+
+func (g *GatewayWsServer) OnClose(_ socket.ISocketConn, _ error) socket.Action {
+	return socket.Close
+}
+
+func (g *GatewayWsServer) OnTick() (time.Duration, socket.Action) {
+	return 5 * time.Second, socket.None
+}