settings

Documentation

Index

• type Body
• type HTTP
• type Headers
• type HeadersNumber
• type HeadersValuesSpace
• type Query
• type Settings
  • func Default() Settings
  • func Fill(src Settings) (modified Settings)
• type TCP
• type TLS
• type URL
• type URLBufferSize
• type URLParams

Types

type Body

type Body struct {
	// MaxSize is responsible for a maximal body size in case it is being transferred
	// using ordinary Content-Length header, otherwise (e.g. chunked TE) this limit,
	// unfortunately, doesn't work
	MaxSize int64
	// MaxChunkSize is responsible for a maximal size of a single chunk being transferred
	// via chunked TE
	MaxChunkSize int64
	// DecodedBufferSize is a size of a buffer, used to store decompressed request body
	DecodedBufferSize int64
}

type HTTP

type HTTP struct {
	// ResponseBuffSize is responsible for a response buffer that is being allocated when
	// client connects and is used for rendering the response into it
	ResponseBuffSize int64
}

type Headers

type Headers struct {
	// Number is responsible for headers map size.
	// Default value is an initial size of allocated headers map.
	// Maximal value is maximum number of headers allowed to be presented
	Number HeadersNumber
	// MaxKeyLength is responsible for maximal header key length restriction.
	MaxKeyLength int
	// MaxValueLength is responsible for maximal header value length restriction.
	MaxValueLength int
	// HeadersValuesSpace is responsible for a maximal space in bytes available for
	// keeping header values in memory.
	// Default value is initial space allocated when client connects.
	// Maximal value is a hard limit, reaching which one client triggers server
	// to response with 431 Header Fields Too Large
	ValueSpace HeadersValuesSpace
	// MaxValuesObjectPoolSize is responsible for a maximal size of string slices object
	// pool
	MaxValuesObjectPoolSize int
	// MaxEncodingTokens is a limit of how many encodings can be applied at the body
	// for a single request
	MaxEncodingTokens int
}

type HeadersNumber

type HeadersNumber struct {
	Default, Maximal int
}

type HeadersValuesSpace

type HeadersValuesSpace struct {
	Default, Maximal int
}

type Query

type Query struct {
	// MaxLength is responsible for a limit of the query length
	MaxLength int
	// DefaultMapSize is responsible for an initial capacity of query entries map.
	// There is no up limit because:
	//   Maximal number of entries equals to 65536 (math.MaxUint16) divided by
	//   3 (minimal length of query entry) that equals to 21,845.
	//   Worst case: sizeof(int) == 64 and sizeof(unsafe.Pointer) == 64. Then
	//   slice type takes 16 bytes
	//   In that case, we can calculate how much memory AT MOST will be used.
	//   24 bytes (slice type - cap, len and pointer 8 bytes each) + 1 byte
	//   (an array of a single char in best case) + 16 bytes (string type - len
	//   and pointer) + 1 byte (an array of single char in best case)
	//   42 bytes in total for each pair, 917490 bytes in total, that is 896 kilobytes
	//   that is 0.87 megabytes. IMHO that is not that much to care about. In case it
	//   is - somebody will open an issue, or even better, implement the limit by himself
	//   (hope he is lucky enough to find out how to handle with my hand-made DI)
	DefaultMapSize int
}

type Settings

type Settings struct {
	Headers Headers
	URL     URL
	TCP     TCP
	Body    Body
	HTTP    HTTP
	TLS     TLS
}

func Default

func Default() Settings

Default returns default settings. Those are initially well-balanced, however maximal defaults are pretty permitting

func Fill

func Fill(src Settings) (modified Settings)

Fill fills zero-values from partially-filled Settings instance with default ones

type TCP

type TCP struct {
	// ReadBufferSize is a size of buffer in bytes which will be used to read from
	// socket
	ReadBufferSize int
	// ReadTimeout is a duration after which client will be automatically disconnected
	ReadTimeout time.Duration
}

type TLS

type TLS struct {
	// Enable states, whether HTTPS will be running (on a separated port).
	Enable bool
	// Port considers, on which port HTTPS listener will be started. By default, it is 443
	Port uint16
	// Cert is a path to the .pem file with the actual certificate.
	// When using certbot, it is usually stored at /etc/letsencrypt/live/<domain>/fullchain.pem
	//
	// By default, just looking for fullchain.pem in the current working directory.
	Cert string
	// Key is a path to the .pem file with the actual key.
	// When using certbot, it is usually stored at /etc/letsencrypt/live/<domain>/privkey.pem
	//
	// By default, just looking for privkey.pem in the current working directory.
	Key string
}

type URL

type URL struct {
	// MaxLength is a size for buffer that'll be allocated once and will be kept
	// until client disconnect
	BufferSize URLBufferSize
	Query      Query
	Params     URLParams
}

type URLBufferSize

type URLBufferSize struct {
	Default, Maximal int
}

type URLParams

type URLParams struct {
	// This option allows user to disable the automatic path params map clearing.
	// May be useful in cases where params keys are being accessed directly only,
	// and nothing tries to get all the map values
	DisableMapClear bool
}