httpu

type Addr string

type Config struct {
	Listeners []ListenerConfig

	Prefix                        string
	RequestPrefixHeader           string `mapstructure:"request_prefix_header" yaml:"request_prefix_header"`
	DisableStripRequestPrefix     bool   `mapstructure:"disable_strip_request_prefix" yaml:"disable_strip_request_prefix"`
	DisableSlashPermanentRedirect bool   `mapstructure:"disable_slash_permanent_redirect" yaml:"disable_slash_permanent_redirect"`
	MaxPostSize                   int64  `mapstructure:"max_post_size" yaml:"max_post_size"`
	UnlimitedPostSize             bool   `mapstructure:"unlimited_request_size" yaml:"unlimited_post_size"`
	NotFoundDisabled              bool   `mapstructure:"not_found_disabled" yaml:"not_found_disabled"`
}

type ContextKey int

type FallbackHandlers []http.Handler

type Http2Config struct {
	Disabled bool
	Config   *http2.Server
}

type KeepAliveConfig struct {
	Duration time.Duration
	Value    string `mapstructure:"str" yaml:"str"`
}

type KeepAliveListener struct {
	net.Listener

	// DefaultKeepAliveCount specifies maximal number of keepalive messages
	// sent before marking connection as dead.
	KeepAliveCount int
	// DefaultKeepAliveIdleInterval specifies how long connection can be idle
	// before sending keepalive message.
	KeepAliveIdleInterval time.Duration
	// DefaultKeepAliveInterval specifies how often retry sending keepalive
	// messages when no response is received.
	KeepAliveInterval time.Duration
}

type Listener struct {
	net.Listener

	Server    *http.Server
	KeepAlive time.Duration
	Tls       *TlsConfig

	Log logging.Logger
	// contains filtered or unexported fields
}

type ListenerConfig struct {
	Addr  Addr
	Tls   *TlsConfig
	Http2 Http2Config

	// DefaultKeepAliveCount specifies maximal number of keepalive messages
	// sent before marking connection as dead.
	KeepAliveCount int
	// DefaultKeepAliveIdleInterval specifies how long connection can be idle
	// before sending keepalive message.
	KeepAliveIdleInterval *KeepAliveConfig
	// DefaultKeepAliveInterval specifies how often retry sending keepalive
	// messages when no response is received.
	KeepAliveInterval *KeepAliveConfig

	Timeouts TimeoutsConfig `mapstructure:"timeouts" yaml:"timeouts"`
}

type Listeners []*Listener

type PrefixHandlers []struct {
	// contains filtered or unexported fields
}

type ResponseWriter interface {
	http.ResponseWriter
	// WroteHeader returns if has sent header to the client.
	WroteHeader() bool
	// Wrote returns if has sent bytes to the client.
	Wrote() bool
	// Status returns the HTTP status of the request, or 0 if one has not
	// yet been sent.
	Status() int
	// BytesWritten returns the total number of bytes sent to the client.
	BytesWritten() int
	// Unwrap returns the original proxied target.
	Unwrap() http.ResponseWriter
}

type Server struct {
	Config  *Config
	Handler http.Handler
	// contains filtered or unexported fields
}

type TeeResponseWriter interface {
	http.ResponseWriter
	// Tee causes the response body to be written to the given io.Writer in
	// addition to proxying the writes through. Only one io.Writer can be
	// tee'd to at once: setting a second one will overwrite the first.
	// Writes will be sent to the proxy before being written to this
	// io.Writer. It is illegal for the tee'd writer to be modified
	// concurrently with writes.
	Tee(io.Writer)
}

type TimeoutsConfig struct {
	// ReadTimeout is the maximum duration for reading the entire
	// request, including the body.
	//
	// Because ReadTimeout does not let Handlers make per-request
	// decisions on each request body's acceptable deadline or
	// upload rate, most users will prefer to use
	// ReadHeaderTimeout. It is valid to use them both.
	ReadTimeout time.Duration `mapstructure:"read_timeout" yaml:"read_timeout"`

	// ReadHeaderTimeout is the amount of time allowed to read
	// request headers. The connection's read deadline is reset
	// after reading the headers and the Handler can decide what
	// is considered too slow for the body. If ReadHeaderTimeout
	// is zero, the value of ReadTimeout is used. If both are
	// zero, there is no timeout.
	ReadHeaderTimeout time.Duration `mapstructure:"read_header_timeout" yaml:"read_header_timeout"`

	// WriteTimeout is the maximum duration before timing out
	// writes of the response. It is reset whenever a new
	// request's header is read. Like ReadTimeout, it does not
	// let Handlers make decisions on a per-request basis.
	WriteTimeout time.Duration `mapstructure:"write_timeout" yaml:"write_timeout"`

	// IdleTimeout is the maximum amount of time to wait for the
	// next request when keep-alives are enabled. If IdleTimeout
	// is zero, the value of ReadTimeout is used. If both are
	// zero, there is no timeout.
	IdleTimeout time.Duration `mapstructure:"idle_timeout" yaml:"idle_timeout"`

	// MaxHeaderBytes controls the maximum number of bytes the
	// server will read parsing the request header's keys and
	// values, including the request line. It does not limit the
	// size of the request body.
	// If zero, DefaultMaxHeaderBytes is used.
	MaxHeaderBytes int `mapstructure:"max_header_bytes" yaml:"max_header_bytes"`
}

type TlsConfig struct {
	Generate    *tlsgen.Config `mapstructure:"generate" yaml:"generate"`
	CertFile    string         `mapstructure:"cert_file" yaml:"cert_file"`
	KeyFile     string         `mapstructure:"key_file" yaml:"key_file"`
	NPNDisabled bool
}