orca

type Args = fasthttp.Args

type BufferConfig struct {
	ReadBufferSize  int `yaml:"read_buffer_size"`
	WriteBufferSize int `yaml:"write_buffer_size"`
}

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

type ConfigDecoder interface {
	Decode(v interface{}) (err error)
}

type ConnConfig struct {
	Concurrency                        int  `yaml:"concurrency"`
	SleepWhenConcurrencyLimitsExceeded int  `yaml:"concurrency_limits_wait"`
	DisableKeepalive                   bool `yaml:"disable_keepalive"`
	MaxConnsPerIP                      int  `yaml:"max_connections"`
	ReadTimeout                        int  `yaml:"read_timeout"`
	WriteTimeout                       int  `yaml:"write_timeout"`
	IdleTimeout                        int  `yaml:"idle_timeout"`
}

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

type Handler = fasthttp.RequestHandler

type HeaderConfig struct {
	Name                          string `yaml:"server"`
	DisableHeaderNamesNormalizing bool   `yaml:"disable_header_names_normalizing"`
	NoDefaultServerHeader         bool   `yaml:"no_default_server_header"`
	NoDefaultDate                 bool   `yaml:"no_default_date"`
	NoDefaultContentType          bool   `yaml:"no_default_content_type"`
}

type HttpClient = fasthttp.Client

type HttpClientConfig struct {
	Name string

	NoDefaultUserAgentHeader bool `yaml:"no_default_ua"`

	// Maximum number of connections per each host which may be established.
	//
	// DefaultMaxConnsPerHost is used if not set.
	MaxConnsPerHost int `yaml:"max_conn_host"`

	// Idle keep-alive connections are closed after this duration.
	//
	// By default idle connections are closed
	// after DefaultMaxIdleConnDuration.
	MaxIdleConnDuration int `yaml:"max_idle_conn_duration"`

	// Keep-alive connections are closed after this duration.
	//
	// By default connection duration is unlimited.
	MaxConnDuration int `yaml:"max_conn_duration"`

	// Maximum number of attempts for idempotent calls
	//
	// DefaultMaxIdemponentCallAttempts is used if not set.
	MaxIdemponentCallAttempts int `yaml:"max_idemponent_call_attempts"`

	// Per-connection buffer size for responses' reading.
	// This also limits the maximum header size.
	//
	// Default buffer size is used if 0.
	ReadBufferSize int `yaml:"read_buffer_size"`

	// Per-connection buffer size for requests' writing.
	//
	// Default buffer size is used if 0.
	WriteBufferSize int `yaml:"write_buffer_size"`

	// Maximum duration for full response reading (including body).
	//
	// By default response read timeout is unlimited.
	ReadTimeout int `yaml:"read_timeout"`

	// Maximum duration for full request writing (including body).
	//
	// By default request write timeout is unlimited.
	WriteTimeout int `yaml:"write_timeout"`

	// Maximum response body size.
	//
	// The client returns ErrBodyTooLarge if this limit is greater than 0
	// and response body is greater than the limit.
	//
	// By default response body size is unlimited.
	MaxResponseBodySize int `yaml:"max_response_body_size"`

	// Header names are passed as-is without normalization
	// if this option is set.
	//
	// Disabled header names' normalization may be useful only for proxying
	// responses to other clients expecting case-sensitive
	// header names. See https://github.com/valyala/fasthttp/issues/57
	// for details.
	//
	// By default request and response header names are normalized, i.e.
	// The first letter and the first letters following dashes
	// are uppercased, while all the other letters are lowercased.
	// Examples:
	//
	//     * HOST -> Host
	//     * content-type -> Content-Type
	//     * cONTENT-lenGTH -> Content-Length
	DisableHeaderNamesNormalizing bool `yaml:"disable_header_names_normalizing"`

	// Path values are sent as-is without normalization
	//
	// Disabled path normalization may be useful for proxying incoming requests
	// to servers that are expecting paths to be forwarded as-is.
	//
	// By default path values are normalized, i.e.
	// extra slashes are removed, special characters are encoded.
	DisablePathNormalizing bool `yaml:"disable_path_normalizing"`

	// Maximum duration for waiting for a free connection.
	//
	// By default will not waiting, return ErrNoFreeConns immediately
	MaxConnWaitTimeout int `yaml:"max_conn_wait_timeout"`
}

type HttpClientHandler func(client *HttpClient, request *Request, response *Response) error

type HttpClientRequestHandler func(client *HttpClient, uri string) (status int, err error)

type KeepaliveConfig struct {
	Addr      string `yaml:"addr"`
	Path      string `yaml:"path"`
	Msg       string `yaml:"msg"`
	Healthy   int    `yaml:"healthy"`
	Unhealthy int    `yaml:"unhealthy"`
	Interval  int    `yaml:"interval"`
	Signal    []int  `yaml:"signal"`
}

type Logger = fasthttp.Logger

type MiddlewareHandler func(*RequestCtx) error

type Option interface {
	// contains filtered or unexported methods
}

type Request = fasthttp.Request

type RequestConfig struct {
	MaxRequestsPerConn int `yaml:"max_requests"`
	MaxRequestBodySize int `yaml:"max_request_body_size"`
}

type RequestCtx = fasthttp.RequestCtx

type RequestHandler = fasthttp.RequestHandler

type RequestHeader = fasthttp.RequestHeader

type Response = fasthttp.Response

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

type RouterAdapter interface {
	Handler(*RequestCtx)
}

type Server = fasthttp.Server

type ServerConfig struct {
	SystemConfig

	Tcp       TcpConfig       `yaml:"tcp"`
	Conn      ConnConfig      `yaml:"conn"`
	Buffer    BufferConfig    `yaml:"buffer"`
	Header    HeaderConfig    `yaml:"header"`
	Request   RequestConfig   `yaml:"request"`
	Keepalive KeepaliveConfig `yaml:"keepalive"`
	AccessLog YamlNode        `yaml:"access_log"`
}

type SystemConfig struct {
	GetOnly                      bool `yaml:"get_only"`
	DisablePreParseMultipartForm bool `yaml:"disable_multipart_parse"`
	ReduceMemoryUsage            bool `yaml:"reduce_memory_usage"`
	LogAllErrors                 bool `yaml:"all_errors"`
}

type TcpConfig struct {
	TCPKeepalive       bool   `yaml:"tcp_keepalive"`
	TCPKeepalivePeriod int    `yaml:"tcp_keepalive_interval"`
	Addr               string `yaml:"addr"`
}

type URI = fasthttp.URI

type YamlNode = yaml.Node