gin

README

Go-Kratos Gin Plugin

fork by https://github.com/go-kratos/gin

Usage

package main

import (
	"context"
	"fmt"
	"log"

	"github.com/gin-gonic/gin"
	kgin "github.com/omalloc/contrib/kratos/gin"
	"github.com/go-kratos/kratos/v2"
	"github.com/go-kratos/kratos/v2/errors"
	"github.com/go-kratos/kratos/v2/middleware"
	"github.com/go-kratos/kratos/v2/middleware/recovery"
	"github.com/go-kratos/kratos/v2/transport"
	"github.com/go-kratos/kratos/v2/transport/http"
)

func customMiddleware(handler middleware.Handler) middleware.Handler {
	return func(ctx context.Context, req interface{}) (reply interface{}, err error) {
		if tr, ok := transport.FromServerContext(ctx); ok {
			fmt.Println("operation:", tr.Operation())
		}
		reply, err = handler(ctx, req)
		return
	}
}

func main() {
	router := gin.Default()
	router.Use(kgin.Middlewares(recovery.Recovery(), customMiddleware))
	router.GET("/helloworld/:name", func(ctx *gin.Context) {
		name := ctx.Param("name")
		if name == "error" {
			kgin.Error(ctx, errors.Unauthorized("auth_error", "no authentication"))
		} else {
			ctx.JSON(200, map[string]string{"welcome": name})
		}
	})

	httpSrv := http.NewServer(http.Address(":8000"))
	httpSrv.HandlePrefix("/", router)

	app := kratos.New(
		kratos.Name("gin"),
		kratos.Server(
			httpSrv,
		),
	)
	if err := app.Run(); err != nil {
		log.Fatal(err)
	}
}

Documentation

Index

• func ContentType(subtype string) string
• func Error(c *gin.Context, err error)
• func FromGinContext(ctx context.Context) (c *gin.Context, ok bool)
• func Middlewares(m ...middleware.Middleware) gin.HandlerFunc
• func NewGinContext(ctx context.Context, c *gin.Context) context.Context

Examples

• Middlewares

Functions

func ContentType

func ContentType(subtype string) string

ContentType returns the content-type with base prefix.

func Error

func Error(c *gin.Context, err error)

Error encodes the object to the HTTP response. It is recommended that you return error directly.

func FromGinContext

func FromGinContext(ctx context.Context) (c *gin.Context, ok bool)

FromGinContext returns the gin.Context value stored in ctx, if any.

func Middlewares

func Middlewares(m ...middleware.Middleware) gin.HandlerFunc

Middlewares return middlewares wrapper

Example

gin.SetMode(gin.ReleaseMode)
r := gin.New()
r.Use(kgin.Middlewares(
	recovery.Recovery(),
	tracing.Server(),
	metadata.Server(),
))

generator := func(value string) string {
	return fmt.Sprintf("hello %s", value)
}

r.GET("/hellworld", func(ctx *gin.Context) {
	v := ctx.Query("name")
	ctx.JSON(200, gin.H{
		"message": generator(v),
	})
})

r.GET("/panic", func(ctx *gin.Context) {
	kgin.Error(ctx, errors.New(500, "want panic", "panic"))
})

r.GET("/nilerr", func(ctx *gin.Context) {
	kgin.Error(ctx, nil)
})
r.GET("/err", func(ctx *gin.Context) {
	ctx.Request.Header.Set("Accept", "application/xml")
	kgin.Error(ctx, errors.New(500, "want err xml", "json xml"))
})

listener, err := net.Listen("tcp", "127.0.0.1:0")
if err != nil {
	panic(err)
}
addr := listener.Addr().String()

httpSrv := http.NewServer(http.Listener(listener))
httpSrv.HandlePrefix("/", r)

app := kratos.New(
	kratos.Name("gin-test"),
	kratos.Server(
		httpSrv,
	),
)

go func() {
	ticker := time.NewTicker(2 * time.Second)

	<-ticker.C
	_ = app.Stop()
}()

go func() {
	ticker := time.NewTicker(200 * time.Millisecond)
	<-ticker.C

	client := resty.New()

	resp, err := client.NewRequest().Get(fmt.Sprintf("http://%s/hellworld?name=gin", addr))
	if err != nil {
		panic(err)
	}

	fmt.Println(resp.String())

	resp, err = client.NewRequest().Get(fmt.Sprintf("http://%s/panic", addr))
	if err != nil {
		panic(err)
	}

	fmt.Println(resp.String())

	resp, err = client.NewRequest().Get(fmt.Sprintf("http://%s/nilerr", addr))
	if err != nil {
		panic(err)
	}

	fmt.Println(resp.String())

	resp, err = client.NewRequest().Get(fmt.Sprintf("http://%s/err", addr))
	if err != nil {
		panic(err)
	}
	fmt.Println(resp.String())
}()

if err := app.Run(); err != nil {
	log.Fatal(err)
}

Output:

{"message":"hello gin"}
{"code":500, "reason":"want panic", "message":"panic", "metadata":{}}

func NewGinContext

func NewGinContext(ctx context.Context, c *gin.Context) context.Context

NewGinContext returns a new Context that carries gin.Context value.