base

type BaseConfig struct {
	Http HttpConfig `json:"http" toml:"http"`
}

type BindFunc func(val interface{}) (interface{}, error)

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

type Cycle uint

type HttpBufferPool struct {
	*sync.Pool
}

type HttpConfig struct {
	// Timeout is the maximum amount of time a dial will wait for
	// a connect to complete. If Deadline is also set, it may fail
	// earlier.
	//
	// The default is no timeout.
	//
	// When using TCP and dialing a host name with multiple IP
	// addresses, the timeout may be divided between them.
	//
	// With or without a timeout, the operating system may impose
	// its own earlier timeout. For instance, TCP timeouts are
	// often around 3 minutes.
	ConnectTimeout time.Duration `json:"connect_timeout" toml:"connect_timeout"`

	// KeepAlive specifies the keep-alive period for an active
	// network connection.
	// If zero, keep-alives are enabled if supported by the protocol
	// and operating system. Network protocols or operating systems
	// that do not support keep-alives ignore this field.
	// If negative, keep-alives are disabled.
	KeepAlive time.Duration `json:"keep_alive" toml:"keep_alive"`

	// MaxIdleConns controls the maximum number of idle (keep-alive)
	// connections across all hosts. Zero means no limit.
	MaxIdleConns int `json:"max_idle_conns" toml:"max_idle_conns"`

	// MaxIdleConnsPerHost, if non-zero, controls the maximum idle
	// (keep-alive) connections to keep per-host. If zero,
	// DefaultMaxIdleConnsPerHost is used.
	MaxIdleConnsPerHost int `json:"max_idle_conns_per_host" toml:"max_idle_conns_per_host"`

	// MaxConnsPerHost optionally limits the total number of
	// connections per host, including connections in the dialing,
	// active, and idle states. On limit violation, dials will block.
	//
	// Zero means no limit.
	//
	// For HTTP/2, this currently only controls the number of new
	// connections being created at a time, instead of the total
	// number. In practice, hosts using HTTP/2 only have about one
	// idle connection, though.
	MaxConnsPerHost int `json:"max_conns_per_host" toml:"max_conns_per_host"`

	// IdleConnTimeout is the maximum amount of time an idle
	// (keep-alive) connection will remain idle before closing
	// itself.
	// Zero means no limit.
	IdleConnTimeout time.Duration `json:"idle_conn_timeout" toml:"idle_conn_timeout"`
	// TLSHandshakeTimeout specifies the maximum amount of time waiting to
	// wait for a TLS handshake. Zero means no timeout.
	TLSHandshakeTimeout time.Duration `json:"tls_handshake_timeout" toml:"tls_handshake_timeout"`

	// DisableCompression, if true, prevents the Transport from
	// requesting compression with an "Accept-Encoding: gzip"
	// request header when the Request contains no existing
	// Accept-Encoding value. If the Transport requests gzip on
	// its own and gets a gzipped response, it's transparently
	// decoded in the Response.Body. However, if the user
	// explicitly requested gzip it is not automatically
	// uncompressed.
	DisableCompression bool `json:"disable_compression" toml:"disable_compression"`

	// ResponseHeaderTimeout, if non-zero, specifies the amount of
	// time to wait for a server's response headers after fully
	// writing the request (including its body, if any). This
	// time does not include the time to read the response body.
	ResponseHeaderTimeout time.Duration `json:"response_header_timeout" toml:"response_header_timeout"`

	// ExpectContinueTimeout, if non-zero, specifies the amount of
	// time to wait for a server's first response headers after fully
	// writing the request headers if the request has an
	// "Expect: 100-continue" header. Zero means no timeout and
	// causes the body to be sent immediately, without
	// waiting for the server to approve.
	// This time does not include the time to send the request header.
	ExpectContinueTimeout time.Duration `json:"expect_continue_timeout" toml:"expect_continue_timeout"`

	// MaxResponseHeaderBytes specifies a limit on how many
	// response bytes are allowed in the server's response
	// header.
	//
	// Zero means to use a default limit.
	MaxResponseHeaderBytes int64 `json:"max_response_header_bytes" toml:"max_response_header_bytes"`

	// WriteBufferSize specifies the size of the write buffer used
	// when writing to the transport.
	// If zero, a default (currently 4KB) is used.
	WriteBufferSize int `json:"write_buffer_size" toml:"write_buffer_size"`

	// ReadBufferSize specifies the size of the read buffer used
	// when reading from the transport.
	// If zero, a default (currently 4KB) is used.
	ReadBufferSize int `json:"read_buffer_size" toml:"read_buffer_size"`

	// ForceAttemptHTTP2 controls whether HTTP/2 is enabled when a non-zero
	// Dial, DialTLS, or DialContext func or TLSClientConfig is provided.
	// By default, use of any those fields conservatively disables HTTP/2.
	// To use a custom dialer or TLS config and still attempt HTTP/2
	// upgrades, set this to true.
	ForceAttemptHTTP2 bool `json:"force_attempt_http_2" toml:"force_attempt_http_2"`

	// Timeout specifies a time limit for requests made by this
	// Client. The timeout includes connection time, any
	// redirects, and reading the response body. The timer remains
	// running after Get, Head, Post, or Do return and will
	// interrupt reading of the Response.Body.
	//
	// A Timeout of zero means no timeout.
	//
	// The Client cancels requests to the underlying Transport
	// as if the Request's Context ended.
	//
	// For compatibility, the Client will also use the deprecated
	// CancelRequest method on Transport if found. New
	// RoundTripper implementations should use the Request's Context
	// for cancelation instead of implementing CancelRequest.
	RequestTimeout time.Duration `json:"request_timeout" toml:"request_timeout"`

	// FlushInterval specifies the flush interval
	// to flush to the client while copying the
	// response body.
	// If zero, no periodic flushing is done.
	// A negative value means to flush immediately
	// after each write to the client.
	// The FlushInterval is ignored when ReverseProxy
	// recognizes a response as a streaming response;
	// for such responses, writes are flushed to the client
	// immediately.
	ProxyFlushInterval time.Duration `json:"proxy_flush_interval" toml:"proxy_flush_interval"`

	// BufferPool optionally specifies a buffer pool to
	// get byte slices for use by io.CopyBuffer when copying HTTP response bodies.
	// Values: none, sync
	ProxyBufferPool string `json:"proxy_buffer_pool" toml:"proxy_buffer_pool"`

	// ErrorHandler is an optional function that handles errors
	// reaching the backend or errors from ModifyResponse.
	// Values: none, body
	ProxyErrorHandler string `json:"proxy_error_handler" toml:"proxy_error_handler"`

	// 用于proxyBufferPool的init size
	HttpBuffSize int `json:"http_buff_size" toml:"http_buff_size"`
}

type IParallel interface {
	Add(func())
	Wait()
	Close()
}

type Level uint

type Logger struct {
	Level Level
	Log   func(level Level, args ...interface{})
	Logf  func(level Level, format string, args ...interface{})
	Flush func()
	Close func()
	// contains filtered or unexported fields
}

type Result struct {
	Code int         `json:"code"`           // 消息代码, 一般地: 0表示无错误, 负表示系统错误, 正表示业务错误
	Msg  string      `json:"msg,omitempty"`  // 消息描述
	Data interface{} `json:"data,omitempty"` // 消息数据
	Tag  string      `json:"tag,omitempty"`  // 消息标签
}