Kratos ares microservice framework (III)

Kratos Ares microservice framework （ 3、 ... and ）

middleware

package auth

import (
   "context"
   "errors"
   "fmt"
   "github.com/davecgh/go-spew/spew"
   "github.com/golang-jwt/jwt/v4"
   "strings"
   "time"

   "github.com/go-kratos/kratos/v2/middleware"
   "github.com/go-kratos/kratos/v2/transport"
)

func GenerateToken(secret, username string) string {
    
   token := jwt.NewWithClaims(jwt.SigningMethodHS256, jwt.MapClaims{
    
      "username": username,
      "nbf":      time.Date(2015, 10, 10, 12, 0, 0, 0, time.UTC).Unix(),
   })

   // Sign and get the complete encoded token as a string using the secret
   tokenString, err := token.SignedString([]byte(secret))
   if err != nil {
    
      panic(err)
   }
   fmt.Println(tokenString, err)
   return tokenString
}

func JWTAuth(secret string) middleware.Middleware {
    
   return func(handler middleware.Handler) middleware.Handler {
    
      return func(ctx context.Context, req interface{
    }) (reply interface{
    }, err error) {
    
         if tr, ok := transport.FromServerContext(ctx); ok {
    
            tokenString := tr.RequestHeader().Get("Authorization")
            auths := strings.SplitN(tokenString, " ", 2)
            if len(auths) != 2 || !strings.EqualFold(auths[0], "Token") {
    
               return nil, errors.New("jwt token missing")
            }

            token, err := jwt.Parse(auths[1], func(token *jwt.Token) (interface{
    }, error) {
    
               if _, ok := token.Method.(*jwt.SigningMethodHMAC); !ok {
    
                  return nil, fmt.Errorf("err %v", token)
               }
               return []byte(secret), nil
            })

            if err != nil {
    
               return nil, err
            }

            if claims, ok := token.Claims.(jwt.MapClaims); ok && token.Valid {
    
               spew.Dump(claims["username"])
            } else {
    
               return nil, errors.New("Token Invalid")
            }

         }
         return handler(ctx, req)
      }
   }
}

func NewHTTPServer(c *conf.Server, jwtc *conf.JWT, greeter *service.RealWorldService, logger log.Logger) *http.Server {
    
   var opts = []http.ServerOption{
    
      http.ErrorEncoder(errorEncoder),
      http.Middleware(
         recovery.Recovery(),
         selector.Server(auth.JWTAuth(jwtc.Token)).Match(NewSkipRoutersMatcher()).Build(), // Add selector filter 
         //auth.JWTAuth(jwtc.Token),
      ),
      http.Filter(handlers.CORS( //  Solving cross domain problems 
         handlers.AllowedHeaders([]string{
    "X-Requested-With", "Content-Type", "Authorization"}),
         handlers.AllowedMethods([]string{
    "GET", "POST", "PUT", "HEAD", "OPTIONS"}),
         handlers.AllowedOrigins([]string{
    "*"}),
      )),
   }
   if c.Http.Network != "" {
    
      opts = append(opts, http.Network(c.Http.Network))
   }
   if c.Http.Addr != "" {
    
      opts = append(opts, http.Address(c.Http.Addr))
   }
   if c.Http.Timeout != nil {
    
      opts = append(opts, http.Timeout(c.Http.Timeout.AsDuration()))
   }
   srv := http.NewServer(opts...)
   v1.RegisterRealWorldHTTPServer(srv, greeter)
   return srv
}

Implement middleware filtering

func NewSkipRoutersMatcher() selector.MatchFunc {
    

   skipRouters := make(map[string]struct{
    })
   skipRouters["/realworld.v1.RealWorld/Login"] = struct{
    }{
    } // jwt Filter login and register
   skipRouters["/realworld.v1.RealWorld/Register"] = struct{
    }{
    }
   return func(ctx context.Context, operation string) bool {
    
      if _, ok := skipRouters[operation]; ok {
    
         return false
      }
      return true
   }
}

Solving cross domain problems

http.Filter(handlers.CORS(
   handlers.AllowedHeaders([]string{
    "X-Requested-With", "Content-Type", "Authorization"}),
   handlers.AllowedMethods([]string{
    "GET", "POST", "PUT", "HEAD", "OPTIONS"}),
   handlers.AllowedOrigins([]string{
    "*"}),
)),

// NewHTTPServer new a HTTP server.
func NewHTTPServer(c *conf.Server, jwtc *conf.JWT, greeter *service.RealWorldService, logger log.Logger) *http.Server {
    
   var opts = []http.ServerOption{
    
      http.ErrorEncoder(errorEncoder),
      http.Middleware(
         recovery.Recovery(),
         selector.Server(auth.JWTAuth(jwtc.Token)).Match(NewSkipRoutersMatcher()).Build(),
         //auth.JWTAuth(jwtc.Token),
      ),
      http.Filter(handlers.CORS( //  To solve the cross domain 
         handlers.AllowedHeaders([]string{
    "X-Requested-With", "Content-Type", "Authorization"}),
         handlers.AllowedMethods([]string{
    "GET", "POST", "PUT", "HEAD", "OPTIONS"}),
         handlers.AllowedOrigins([]string{
    "*"}),
      )),
   }
   if c.Http.Network != "" {
    
      opts = append(opts, http.Network(c.Http.Network))
   }
   if c.Http.Addr != "" {
    
      opts = append(opts, http.Address(c.Http.Addr))
   }
   if c.Http.Timeout != nil {
    
      opts = append(opts, http.Timeout(c.Http.Timeout.AsDuration()))
   }
   srv := http.NewServer(opts...)
   v1.RegisterRealWorldHTTPServer(srv, greeter)
   return srv
}

Custom error

package errors

import (
   "errors"
   "fmt"
)

type HTTPError struct {
    
   Errors map[string][]string `json:"errors"`
   Code   int                 `json:"-"`
}

func NewHTTPError(code int, field string, detail string) *HTTPError {
    
   return &HTTPError{
    Code: code, Errors: map[string][]string{
    
      field: {
    detail},
   }}
}

func (e *HTTPError) Error() string {
    
   return fmt.Sprintf("HTTPError %d", e.Code)
}

func FromError(err error) *HTTPError {
    
   if err == nil {
    
      return nil
   }
   if se := new(HTTPError); errors.As(err, &se) {
    
      return se
   }
   return &HTTPError{
    }
}

package server

import (
   "github.com/go-kratos/kratos/v2/transport/http"
   e "helloworld/internal/errors"
   stdhttp "net/http"
)

func errorEncoder(w stdhttp.ResponseWriter, r *stdhttp.Request, err error) {
    
   se := e.FromError(err)
   codec, _ := http.CodecForRequest(r, "Accept")
   body, err := codec.Marshal(se)
   if err != nil {
    
      w.WriteHeader(500)
      return
   }
   w.Header().Set("Content-Type", "application/"+codec.Name())
   w.WriteHeader(se.Code)
   _, _ = w.Write(body)
}

Use ：

func (s *RealWorldService) Login(ctx context.Context, req *v1.LoginRequest) (*v1.UserReply, error) {
    

   if len(req.User.Email) == 0 {
    
      return nil, errors.NewHTTPError(422, "email", "can't be empty")

   }

   return &v1.UserReply{
    
      User: &v1.UserReply_User{
    
         Username: "jjj",
      },
   }, nil
}