gin

Documentation

Overview

Package gin provides some basic implementations for building routers based on gin-gonic/gin

Index

• Constants
• Variables
• func DebugHandler(logger logging.Logger) gin.HandlerFunc
• func DefaultFactory(proxyFactory proxy.Factory, logger logging.Logger) router.Factory
• func EchoHandler() gin.HandlerFunc
• func NewEngine(cfg config.ServiceConfig, opt EngineOptions) *gin.Engine
• func NewFactory(cfg Config) router.Factory
• func NewRequest(headersToSend []string) func(*gin.Context, []string) *proxy.Request
• func RegisterRender(name string, r Render)
• type Config
• type EngineOptions
• type HandlerFactory
  • func CustomErrorEndpointHandler(logger logging.Logger, errF server.ToHTTPError) HandlerFactory
• type Render
• type RunServerFunc

Constants

const NEGOTIATE = "negotiate"

NEGOTIATE defines the value of the OutputEncoding for the negotiated render

const Namespace = "github_com/luraproject/lura/router/gin"

const XML = "xml"

const YAML = "yaml"

Variables

var EndpointHandler = CustomErrorEndpointHandler(logging.NoOp, server.DefaultToHTTPError)

EndpointHandler implements the HandlerFactory interface using the default ToHTTPError function

var ErrorResponseWriter = func(c *gin.Context, err error) {
	if te, ok := err.(encodedResponseError); ok && te.Encoding() != "" {
		c.Header("Content-Type", te.Encoding())
	}
	c.Writer.WriteString(err.Error())
}

ErrorResponseWriter writes the string representation of an error into the response body and sets a Content-Type header for errors that implement the encodedResponseError interface.

Functions

func DebugHandler

func DebugHandler(logger logging.Logger) gin.HandlerFunc

DebugHandler creates a dummy handler function, useful for quick integration tests

func DefaultFactory

func DefaultFactory(proxyFactory proxy.Factory, logger logging.Logger) router.Factory

DefaultFactory returns a gin router factory with the injected proxy factory and logger. It also uses a default gin router and the default HandlerFactory

func EchoHandler

func EchoHandler() gin.HandlerFunc

EchoHandler creates a dummy handler function, useful for quick integration tests

func NewEngine

func NewEngine(cfg config.ServiceConfig, opt EngineOptions) *gin.Engine

NewEngine returns an initialized gin engine

func NewFactory

func NewFactory(cfg Config) router.Factory

NewFactory returns a gin router factory with the injected configuration

func NewRequest

func NewRequest(headersToSend []string) func(*gin.Context, []string) *proxy.Request

NewRequest gets a request from the current gin context and the received query string

func RegisterRender

func RegisterRender(name string, r Render)

RegisterRender allows clients to register their custom renders

Types

type Config

type Config struct {
	Engine         *gin.Engine
	Middlewares    []gin.HandlerFunc
	HandlerFactory HandlerFactory
	ProxyFactory   proxy.Factory
	Logger         logging.Logger
	RunServer      RunServerFunc
}

Config is the struct that collects the parts the router should be builded from

type EngineOptions

type EngineOptions struct {
	Logger    logging.Logger
	Writer    io.Writer
	Formatter gin.LogFormatter
	Health    <-chan string
}

type HandlerFactory

type HandlerFactory func(*config.EndpointConfig, proxy.Proxy) gin.HandlerFunc

HandlerFactory creates a handler function that adapts the gin router with the injected proxy

func CustomErrorEndpointHandler

func CustomErrorEndpointHandler(logger logging.Logger, errF server.ToHTTPError) HandlerFactory

CustomErrorEndpointHandler returns a HandlerFactory using the injected ToHTTPError function and logger

type Render

type Render func(*gin.Context, *proxy.Response)

Render defines the signature of the functions to be use for the final response encoding and rendering

type RunServerFunc

type RunServerFunc func(context.Context, config.ServiceConfig, http.Handler) error

RunServerFunc is a func that will run the http Server with the given params.