feature(error): 错误处理

opms_libary/micro_srv/micro_srv.go

@@ -119,7 +119,7 @@ func streamHandler(conn net.Conn, args *share.StreamServiceArgs) {
 		return
 	}
 
-	resp := validToken(token)
+	resp := validToken(ctx, token)
 	if resp.Code != 0 {
 		result, _ := handError(myerrors.AuthError())
 		conn.Write(result)
@@ -191,35 +191,27 @@ func getTenant(msg *protocol.Message) string {
 
 // HandleAuth 处理Auth认证
 func HandleAuth(ctx context.Context, req *protocol.Message, token string, authExcludePaths []string) error {
-	path := "/" + req.ServicePath + "/" + req.ServiceMethod
-	//g.Log().Info("reqPath: ", path)
-	//g.Log().Info("token: ", token)
-	g.Log().Info("Received " + path + " request @ " + getTenant(req))
+	reqPath := "/" + req.ServicePath + "/" + req.ServiceMethod
+	tenant := getTenant(req)
+	g.Log().Info("Received " + reqPath + " request @ " + tenant)
 
-	if authPath(path, authExcludePaths) {
+	if authPath(reqPath, authExcludePaths) {
 		req.Metadata["authExclude"] = "false"
 		var rsp gtoken.Resp
 		notAuthSrv := ctx.Value("NotAuthSrv")
 		if notAuthSrv != nil && notAuthSrv.(bool) {
 			rsp = gtoken.GFToken.ValidToken(token)
 		} else {
-			rsp = validToken(token)
+			ctx = context.WithValue(ctx, share.ReqMetaDataKey, map[string]string{"tenant": tenant})
+			rsp = validToken(ctx, token)
 		}
 
-		//return errors.New("InvalidToken")
 		if rsp.Code != 0 && rsp.Code != 200 {
 			return myerrors.AuthError()
 		}
-
-		//userInfo, err := getUserInfoFromToken(rsp)
-		//if err!=nil{
-		//	return err
-		//}
-		//g.Dump(userInfo)
 		if req.Metadata != nil {
 			req.Metadata["userInfo"] = rsp.DataString()
 		}
-
 		return nil
 	}
 	return nil
@@ -258,7 +250,7 @@ func authPath(urlPath string, authExcludePaths []string) bool {
 }
 
 // 验证token
-func validToken(token string) gtoken.Resp {
+func validToken(ctx context.Context, token string) gtoken.Resp {
 	grsp := gtoken.Resp{}
 	if token == "" {
 		grsp.Code = 401
@@ -269,7 +261,7 @@ func validToken(token string) gtoken.Resp {
 	authService := InitMicroSrvClient("Auth", "micro_srv.auth")
 	defer authService.Close()
 	rsp := &comm_def.CommonMsg{}
-	err := authService.Call(context.TODO(), "ValidToken", token, rsp)
+	err := authService.Call(ctx, "ValidToken", token, rsp)
 	if err != nil {
 		g.Log().Error(err)
 		grsp.Code = 401

opms_libary/myerrors/error.go

@@ -2,12 +2,13 @@ package myerrors
 
 import (
 	"context"
-	"dashoo.cn/common_definition/comm_def"
+	"fmt"
 	"github.com/gogf/gf/errors/gcode"
 	"github.com/gogf/gf/errors/gerror"
 	"github.com/gogf/gf/frame/g"
 	"github.com/smallnest/rpcx/codec"
 	"github.com/smallnest/rpcx/protocol"
+	"github.com/smallnest/rpcx/share"
 	"strings"
 )
 
@@ -83,37 +84,37 @@ func handleErrMsg(errCode gcode.Code, errMsg ...string) string {
 
 type HandleErrorPlugin struct{}
 
-func (p HandleErrorPlugin) getSerializeType(mes *protocol.Message) codec.Codec {
-	var serializer codec.Codec
+func (p HandleErrorPlugin) getSerializeType(mes *protocol.Message) (codec.Codec, g.Map) {
+	var err error
+	serializer := share.Codecs[mes.SerializeType()]
+	data := g.Map{}
 	switch mes.SerializeType() {
 	case protocol.SerializeNone:
-		return nil
 	case protocol.JSON:
-		serializer = codec.JSONCodec{}
+		err = serializer.Decode(mes.Payload, &data)
 	case protocol.ProtoBuffer:
-		serializer = codec.PBCodec{}
 	case protocol.MsgPack:
-		serializer = codec.MsgpackCodec{}
+		err = serializer.Decode(mes.Payload, &data)
 	case protocol.Thrift:
-		serializer = codec.ThriftCodec{}
 	}
-	return serializer
+	fmt.Println(err)
+	return serializer, data
 }
 
 func (p HandleErrorPlugin) PreWriteResponse(ctx context.Context, req *protocol.Message, res *protocol.Message, err error) error {
-	resData := new(comm_def.CommonMsg)
-	serializer := p.getSerializeType(res)
+	serializer := share.Codecs[res.SerializeType()]
+	var resData g.Map
+	if serializerErr := serializer.Decode(res.Payload, &resData); serializerErr != nil {
+		return serializerErr
+	}
+
 	if err == nil {
 		// todo 正常数据处理
-		if serializerErr := serializer.Decode(res.Payload, resData); serializerErr != nil {
-			return serializerErr
-		}
-
-		if resData.Code == 0 {
-			resData.Code = 200
+		if resData["code"] == 0 {
+			resData["code"] = 200
 		}
-		if resData.Msg == "" {
-			resData.Msg = "操作成功"
+		if resData["msg"] == "" {
+			resData["msg"] = "操作成功"
 		}
 		res.Payload, _ = serializer.Encode(resData)
 		return nil
@@ -130,24 +131,24 @@ func (p HandleErrorPlugin) PreWriteResponse(ctx context.Context, req *protocol.M
 	switch true {
 	case nextErrCode > 1000:
 		// 业务级异常处理
-		resData.Code = int32(topCode)
-		resData.Msg = err.Error()
+		resData["code"] = int32(topCode)
+		resData["msg"] = err.Error()
 
 	case nextErrCode == gcode.CodeValidationFailed.Code():
 		// goframe 数据校验
 		// 检查是否存在业务信息，添加显示
-		resData.Code = int32(codeValidErr.Code())
-		resData.Msg = codeValidErr.Message() + ": " + err.Error()
+		resData["code"] = int32(codeValidErr.Code())
+		resData["msg"] = codeValidErr.Message() + ": " + err.Error()
 
 	case nextErrCode > 0 && topCode > 1000:
 		// 检查是否存在业务信息，添加显示
-		resData.Code = int32(topCode)
-		resData.Msg = splitErrorStr(err.Error())
+		resData["code"] = int32(topCode)
+		resData["msg"] = splitErrorStr(err.Error())
 
 	default:
 		// 默认返回系统级异常处理
-		resData.Code = int32(codeSysErr.Code())
-		resData.Msg = codeSysErr.Message()
+		resData["code"] = int32(codeSysErr.Code())
+		resData["msg"] = codeSysErr.Message()
 	}
 	res.Payload, _ = serializer.Encode(resData)
 	res.SetMessageStatusType(protocol.Normal)