httpserver

package
v0.17.2 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: May 10, 2024 License: MIT Imports: 42 Imported by: 0

Documentation

Index

Constants

View Source
const (
	ApiViewKey          = "X-Api-View"
	ContentTypeHtml     = "text/html; charset=utf-8"
	ContentTypeJson     = "application/json; charset=utf-8"
	ContentTypeProtobuf = "application/x-protobuf"
)
View Source
const (
	MetricHttpRequestCount        = "HttpRequestCount"
	MetricHttpRequestResponseTime = "HttpRequestResponseTime"
	MetricHttpStatus              = "HttpStatus"
)
View Source
const (
	BaseProfiling = "/debug/profiling"
	CmdLine       = "/cmdline"
	Profile       = "/profile"
	Symbol        = "/symbol"
	Trace         = "/trace"
	Allocs        = "/allocs"
	Block         = "/block"
	GoRoutine     = "/goroutine"
	Heap          = "/heap"
	Mutex         = "/mutex"
	ThreadCreate  = "/threadcreate"
)

Variables

View Source
var ErrAccessForbidden = errors.New("cant access resource")

Functions

func AddCustomTypeFuncs

func AddCustomTypeFuncs(customTypeFuncs []CustomTypeFunc) error

func AddCustomValidators

func AddCustomValidators(customValidators []CustomValidator) error

func AddProfilingEndpoints

func AddProfilingEndpoints(r *gin.Engine)

func AddStructValidators

func AddStructValidators(structValidators []StructValidator) error

func AddValidateAlias

func AddValidateAlias(aliases []ValidateAlias) error

func Cors

func Cors(config cfg.Config) gin.HandlerFunc

func CreateDownloadHandler

func CreateDownloadHandler(handler HandlerWithStream) gin.HandlerFunc

func CreateHandler

func CreateHandler(handler HandlerWithoutInput) gin.HandlerFunc

func CreateJsonHandler

func CreateJsonHandler(handler HandlerWithInput) gin.HandlerFunc

func CreateMultiPartFormHandler

func CreateMultiPartFormHandler(handler HandlerWithInput) gin.HandlerFunc

func CreateMultipleBindingsHandler

func CreateMultipleBindingsHandler(handler HandlerWithMultipleBindings) gin.HandlerFunc

func CreateProtobufHandler added in v0.16.0

func CreateProtobufHandler(handler HandlerWithInput) gin.HandlerFunc

func CreateQueryHandler

func CreateQueryHandler(handler HandlerWithInput) gin.HandlerFunc

func CreateRawHandler

func CreateRawHandler(handler HandlerWithoutInput) gin.HandlerFunc

func CreateReaderHandler

func CreateReaderHandler(handler HandlerWithoutInput) gin.HandlerFunc

func CreateSseHandler

func CreateSseHandler(handler HandlerWithStream) gin.HandlerFunc

func CreateStreamHandler

func CreateStreamHandler(handler HandlerWithStream) gin.HandlerFunc

func GetStringFromRequest

func GetStringFromRequest(request *Request, name string) (*string, bool)

func GetUintFromRequest

func GetUintFromRequest(request *Request, name string) (*uint, bool)

func HttpTest

func HttpTest[Body HttpBody](method string, path string, requestPath string, body Body, handler gin.HandlerFunc, requestOptions ...func(r *http.Request)) *httptest.ResponseRecorder

func LoggingMiddleware

func LoggingMiddleware(logger log.Logger, settings LoggingSettings) gin.HandlerFunc

func New

func New(name string, definer Definer) kernel.ModuleFactory

func NewCountingBodyReader

func NewCountingBodyReader(reader io.ReadCloser) (io.ReadCloser, *int)

func NewCountingBodyWriter

func NewCountingBodyWriter(writer gin.ResponseWriter) (gin.ResponseWriter, *int)

func NewGZipBodyReader

func NewGZipBodyReader(body io.ReadCloser) (io.ReadCloser, *int, error)

func NewHealthCheck

func NewHealthCheck() kernel.ModuleFactory

func NewMetricMiddleware

func NewMetricMiddleware(name string) (middleware gin.HandlerFunc, setupHandler func(definitions []Definition))

func NewProfiling

func NewProfiling() kernel.ModuleFactory

func NewWithSettings

func NewWithSettings(name string, definer Definer, settings *Settings) kernel.ModuleFactory

func RecoveryWithSentry

func RecoveryWithSentry(logger log.Logger) gin.HandlerFunc

func WithCustomModifier

func WithCustomModifier(modifier Modifier)

func WithErrorHandler

func WithErrorHandler(handler ErrorHandler)

Types

type ApiHealthCheck

type ApiHealthCheck struct {
	kernel.BackgroundModule
	kernel.ServiceStage
	// contains filtered or unexported fields
}

func NewHealthCheckWithInterfaces

func NewHealthCheckWithInterfaces(logger log.Logger, router *gin.Engine, healthChecker kernel.HealthChecker, settings *HealthCheckSettings) *ApiHealthCheck

func (*ApiHealthCheck) Run

func (a *ApiHealthCheck) Run(ctx context.Context) error

type CompressionExcludeSettings

type CompressionExcludeSettings struct {
	Extension []string `cfg:"extension"`
	Path      []string `cfg:"path"`
	PathRegex []string `cfg:"path_regex"`
}

CompressionExcludeSettings allow enabling of gzip support.

type CompressionSettings

type CompressionSettings struct {
	Level         string `cfg:"level" default:"default" validate:"oneof=none default best fast 0 1 2 3 4 5 6 7 8 9"`
	Decompression bool   `cfg:"decompression" default:"true"`
	// Exclude files by path, extension, or regular expression from being considered for compression. Useful if you are serving a format unknown to Gosoline.
	Exclude CompressionExcludeSettings `cfg:"exclude"`
}

CompressionSettings control gzip support for requests and responses. By default, compressed requests are accepted and compressed responses are returned (if accepted by the client).

type CustomTypeFunc

type CustomTypeFunc struct {
	Func  validator.CustomTypeFunc
	Types []interface{}
}

A CustomTypeFunc allows you to convert one type to another type before validation. This allows you to validate custom types with the built-in functions for, e.g., integers or strings.

type CustomValidator

type CustomValidator struct {
	Name      string
	Validator validator.Func
}

A CustomValidator allows you to validate single fields with custom rules. If you need to validate a whole struct, you need to use a StructValidator. See https://github.com/go-playground/validator/issues/470 for more details.

type Definer

type Definer func(ctx context.Context, config cfg.Config, logger log.Logger) (*Definitions, error)

type Definition

type Definition struct {
	// contains filtered or unexported fields
}

type Definitions

type Definitions struct {
	// contains filtered or unexported fields
}

func (*Definitions) DELETE

func (d *Definitions) DELETE(relativePath string, handlers ...gin.HandlerFunc)

func (*Definitions) GET

func (d *Definitions) GET(relativePath string, handlers ...gin.HandlerFunc)

func (*Definitions) Group

func (d *Definitions) Group(relativePath string) *Definitions

func (*Definitions) Handle

func (d *Definitions) Handle(httpMethod, relativePath string, handlers ...gin.HandlerFunc)

func (*Definitions) OPTIONS

func (d *Definitions) OPTIONS(relativePath string, handlers ...gin.HandlerFunc)

func (*Definitions) POST

func (d *Definitions) POST(relativePath string, handlers ...gin.HandlerFunc)

func (*Definitions) PUT

func (d *Definitions) PUT(relativePath string, handlers ...gin.HandlerFunc)

func (*Definitions) Use

func (d *Definitions) Use(middleware ...gin.HandlerFunc)

type ErrorHandler

type ErrorHandler func(statusCode int, err error) *Response

func GetErrorHandler

func GetErrorHandler() ErrorHandler

type HandlerMetadata

type HandlerMetadata struct {
	// Method is the route method of this Handler.
	Method string `json:"method"`
	// Path is the route path ot this handler.
	Path string `json:"path"`
}

HandlerMetadata stores the Path and Method of this Handler.

type HandlerWithInput

type HandlerWithInput interface {
	HandlerWithoutInput
	GetInput() interface{}
}

type HandlerWithMultipleBindings

type HandlerWithMultipleBindings interface {
	HandlerWithInput
	GetBindings() []binding.Binding
}

type HandlerWithStream

type HandlerWithStream interface {
	GetInput() interface{}
	Handle(ginContext *gin.Context, requestContext context.Context, request *Request) (err error)
}

type HandlerWithoutInput

type HandlerWithoutInput interface {
	Handle(requestContext context.Context, request *Request) (response *Response, err error)
}

type HealthCheckSettings

type HealthCheckSettings struct {
	Port int    `cfg:"port" default:"8090"`
	Path string `cfg:"path" default:"/health"`
}

type HttpBody added in v0.16.0

type HttpBody interface {
	string | []byte
}

type HttpServer

type HttpServer struct {
	kernel.EssentialModule
	kernel.ServiceStage
	// contains filtered or unexported fields
}

func NewWithInterfaces

func NewWithInterfaces(logger log.Logger, router *gin.Engine, tracer tracing.Tracer, s *Settings) (*HttpServer, error)

func (*HttpServer) GetPort

func (a *HttpServer) GetPort() (*int, error)

func (*HttpServer) Run

func (a *HttpServer) Run(ctx context.Context) error

type LoggingSettings

type LoggingSettings struct {
	RequestBody       bool `cfg:"request_body"`
	RequestBodyBase64 bool `cfg:"request_body_base64"`
}

type Modifier

type Modifier interface {
	Struct(ctx context.Context, v interface{}) error
}

type Profiling

type Profiling struct {
	kernel.BackgroundModule
	kernel.ServiceStage
	// contains filtered or unexported fields
}

func NewProfilingWithInterfaces

func NewProfilingWithInterfaces(logger log.Logger, router *gin.Engine, settings *ProfilingSettings) *Profiling

func (*Profiling) Run

func (p *Profiling) Run(ctx context.Context) error

type ProfilingSettings

type ProfilingSettings struct {
	Port int `cfg:"port" default:"8091"`
}

type ProtobufDecodable added in v0.16.0

type ProtobufDecodable interface {
	// EmptyMessage should provide an empty instance of the message format to decode from.
	EmptyMessage() proto.Message
	// FromMessage should extract the data from the message and write it to the receiver.
	FromMessage(message proto.Message) error
}

ProtobufDecodable allows CreateProtobufHandler to decode the request body via protobuf.

type ProtobufEncodable added in v0.16.0

type ProtobufEncodable interface {
	// ToMessage turns the response value into a protobuf message representation
	ToMessage() (proto.Message, error)
}

ProtobufEncodable is required for NewProtobufResponse to create the protobuf response.

type Request

type Request struct {
	Body     interface{}
	ClientIp string
	Cookies  map[string]string
	Header   http.Header
	Method   string
	Params   gin.Params
	Url      *url.URL
}

type Response

type Response struct {
	Body        interface{}
	ContentType *string // might be nil
	Header      http.Header
	StatusCode  int
}

Don't create a response directly, use New*Response instead

func NewHtmlResponse

func NewHtmlResponse(body interface{}) *Response

func NewJsonResponse

func NewJsonResponse(body interface{}) *Response

func NewProtobufResponse added in v0.16.0

func NewProtobufResponse(body ProtobufEncodable) (*Response, error)

func NewRedirectResponse

func NewRedirectResponse(url string) *Response

func NewResponse

func NewResponse(body interface{}, contentType string, statusCode int, header http.Header) *Response

func NewStatusResponse

func NewStatusResponse(statusCode int) *Response

func (*Response) AddHeader

func (r *Response) AddHeader(key string, value string)

func (*Response) WithBody

func (r *Response) WithBody(body interface{}) *Response

func (*Response) WithContentType

func (r *Response) WithContentType(contentType string) *Response

type ResponseBodyWriterError

type ResponseBodyWriterError struct {
	Err error
}

func (ResponseBodyWriterError) Error

func (e ResponseBodyWriterError) Error() string

func (ResponseBodyWriterError) Is

func (ResponseBodyWriterError) Unwrap

func (e ResponseBodyWriterError) Unwrap() error

type ServerMetadata

type ServerMetadata struct {
	Name     string            `json:"name"`
	Handlers []HandlerMetadata `json:"handlers"`
}

type Settings

type Settings struct {
	// Port the API listens to.
	Port string `cfg:"port" default:"8080"`
	// Mode is either debug, release, test.
	Mode string `cfg:"mode" default:"release" validate:"oneof=release debug test"`
	// Compression settings.
	Compression CompressionSettings `cfg:"compression"`
	// Timeout settings.
	Timeout TimeoutSettings `cfg:"timeout"`
	// Logging settings
	Logging LoggingSettings `cfg:"logging"`
}

Settings structure for an API server.

type StructValidator

type StructValidator struct {
	Struct    interface{}
	Validator validator.StructLevelFunc
}

A StructValidator validates every instance of a struct type with the given validation. It is a little bit unfortunate because you now can't have different validation rules for a struct at different places.

type TimeoutSettings

type TimeoutSettings struct {
	// You need to give at least 1s as timeout.
	// Read timeout is the maximum duration for reading the entire request, including the body.
	Read time.Duration `cfg:"read" default:"60s" validate:"min=1000000000"`
	// Write timeout is the maximum duration before timing out writes of the response.
	Write time.Duration `cfg:"write" default:"60s" validate:"min=1000000000"`
	// Idle timeout is the maximum amount of time to wait for the next request when keep-alives are enabled
	Idle time.Duration `cfg:"idle" default:"60s" validate:"min=1000000000"`
}

TimeoutSettings configures IO timeouts.

type ValidateAlias

type ValidateAlias struct {
	Alias string
	Tags  string
}

A ValidateAlias allows you to map one or more tags to a different name, making your validation rules easier to read.

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL