httpserver

Documentation

Index

• Constants
• type Config
  • func (c *Config) CheckTLS() (libtls.TLSConfig, liberr.Error)
  • func (c *Config) Clone() Config
  • func (c *Config) GetExpose() *url.URL
  • func (c *Config) GetHandlerKey() string
  • func (c *Config) GetListen() *url.URL
  • func (c *Config) GetTLS() (libtls.TLSConfig, liberr.Error)
  • func (c *Config) IsTLS() bool
  • func (c *Config) RegisterHandlerFunc(hdl srvtps.FuncHandler)
  • func (c *Config) Server(defLog liblog.FuncLog) (Server, error)
  • func (c *Config) SetContext(f libctx.FuncContext)
  • func (c *Config) SetDefaultTLS(f libtls.FctTLSDefault)
  • func (c *Config) Validate() liberr.Error
• type Info
• type Server
  • func New(cfg Config, defLog liblog.FuncLog) (Server, error)

Constants

const (
	ErrorParamEmpty liberr.CodeError = iota + liberr.MinPkgHttpServer
	ErrorHTTP2Configure
	ErrorServerValidate
	ErrorServerStart
	ErrorPortUse
)

const (
	DefaultNameMonitor = "HTTP Server"
)

Types

type Config

type Config struct {

	// Name is the name of the current srv
	// the configuration allow multipke srv, which each one must be identify by a name
	// If not defined, will use the listen address
	Name string `mapstructure:"name" json:"name" yaml:"name" toml:"name" validate:"required"`

	// Listen is the local address (ip, hostname, unix socket, ...) with a port
	// The srv will bind with this address only and listen for the port defined
	Listen string `mapstructure:"listen" json:"listen" yaml:"listen" toml:"listen" validate:"required,hostname_port"`

	// Expose is the address use to call this srv. This can be allow to use a single fqdn to multiple srv"
	Expose string `mapstructure:"expose" json:"expose" yaml:"expose" toml:"expose" validate:"required,url"`

	// HandlerKey is an options to associate current srv with a specifc handler defined by the key
	// This key allow to defined multiple srv in only one config for different handler to start multiple api
	HandlerKey string `mapstructure:"handler_key" json:"handler_key" yaml:"handler_key" toml:"handler_key"`

	// Enabled allow to disable a srv without clean his configuration
	Disabled bool `mapstructure:"disabled" json:"disabled" yaml:"disabled" toml:"disabled"`

	// Monitor defined the monitoring options to monitor the status & metrics about the health of this srv
	Monitor moncfg.Config `mapstructure:"monitor" json:"monitor" yaml:"monitor" toml:"monitor"`

	// TLSMandatory is a flag to defined that TLS must be valid to start current srv.
	TLSMandatory bool `mapstructure:"tls_mandatory" json:"tls_mandatory" yaml:"tls_mandatory" toml:"tls_mandatory"`

	// TLS is the tls configuration for this srv.
	// To allow tls on this srv, at least the TLS Config option InheritDefault must be at true and the default TLS config must be set.
	// If you don't want any tls config, just omit or set an empty struct.
	TLS libtls.Config `mapstructure:"tls" json:"tls" yaml:"tls" toml:"tls"`

	// 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" json:"read_timeout" yaml:"read_timeout" toml:"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" json:"read_header_timeout" yaml:"read_header_timeout" toml:"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" json:"write_timeout" yaml:"write_timeout" toml:"write_timeout"`

	// MaxHeaderBytes controls the maximum number of bytes the
	// srv 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" json:"max_header_bytes" yaml:"max_header_bytes" toml:"max_header_bytes"`

	// MaxHandlers limits the number of http.Handler ServeHTTP goroutines
	// which may run at a time over all connections.
	// Negative or zero no limit.
	MaxHandlers int `mapstructure:"max_handlers" json:"max_handlers" yaml:"max_handlers" toml:"max_handlers"`

	// MaxConcurrentStreams optionally specifies the number of
	// concurrent streams that each client may have open at a
	// time. This is unrelated to the number of http.Handler goroutines
	// which may be active globally, which is MaxHandlers.
	// If zero, MaxConcurrentStreams defaults to at least 100, per
	// the HTTP/2 spec's recommendations.
	MaxConcurrentStreams uint32 `` /* 127-byte string literal not displayed */

	// MaxReadFrameSize optionally specifies the largest frame
	// this srv is willing to read. A valid value is between
	// 16k and 16M, inclusive. If zero or otherwise invalid, a
	// default value is used.
	MaxReadFrameSize uint32 `mapstructure:"max_read_frame_size" json:"max_read_frame_size" yaml:"max_read_frame_size" toml:"max_read_frame_size"`

	// PermitProhibitedCipherSuites, if true, permits the use of
	// cipher suites prohibited by the HTTP/2 spec.
	PermitProhibitedCipherSuites bool `` /* 163-byte string literal not displayed */

	// IdleTimeout specifies how long until idle clients should be
	// closed with a GOAWAY frame. PING frames are not considered
	// activity for the purposes of IdleTimeout.
	IdleTimeout time.Duration `mapstructure:"idle_timeout" json:"idle_timeout" yaml:"idle_timeout" toml:"idle_timeout"`

	// MaxUploadBufferPerConnection is the size of the initial flow
	// control window for each connections. The HTTP/2 spec does not
	// allow this to be smaller than 65535 or larger than 2^32-1.
	// If the value is outside this range, a default value will be
	// used instead.
	MaxUploadBufferPerConnection int32 `` /* 167-byte string literal not displayed */

	// MaxUploadBufferPerStream is the size of the initial flow control
	// window for each stream. The HTTP/2 spec does not allow this to
	// be larger than 2^32-1. If the value is zero or larger than the
	// maximum, a default value will be used instead.
	MaxUploadBufferPerStream int32 `` /* 151-byte string literal not displayed */

	// DisableKeepAlive controls whether HTTP keep-alives are disabled.
	// By default, keep-alives are always enabled. Only very
	// resource-constrained environments or servers in the process of
	// shutting down should disable them.
	DisableKeepAlive bool `mapstructure:"disable_keep_alive" json:"disable_keep_alive" yaml:"disable_keep_alive" toml:"disable_keep_alive"`

	// Logger is used to define the logger options.
	Logger logcfg.Options `mapstructure:"logger" json:"logger" yaml:"logger" toml:"logger"`
	// contains filtered or unexported fields
}

nolint #maligned

func (*Config) CheckTLS

func (c *Config) CheckTLS() (libtls.TLSConfig, liberr.Error)

func (*Config) Clone

func (c *Config) Clone() Config

func (*Config) GetExpose

func (c *Config) GetExpose() *url.URL

func (*Config) GetHandlerKey

func (c *Config) GetHandlerKey() string

func (*Config) GetListen

func (c *Config) GetListen() *url.URL

func (*Config) GetTLS

func (c *Config) GetTLS() (libtls.TLSConfig, liberr.Error)

func (*Config) IsTLS

func (c *Config) IsTLS() bool

func (*Config) RegisterHandlerFunc

func (c *Config) RegisterHandlerFunc(hdl srvtps.FuncHandler)

func (*Config) Server

func (c *Config) Server(defLog liblog.FuncLog) (Server, error)

func (*Config) SetContext

func (c *Config) SetContext(f libctx.FuncContext)

func (*Config) SetDefaultTLS

func (c *Config) SetDefaultTLS(f libtls.FctTLSDefault)

func (*Config) Validate

func (c *Config) Validate() liberr.Error

type Info

type Info interface {
	GetName() string
	GetBindable() string
	GetExpose() string

	IsDisable() bool
	IsTLS() bool
}

type Server

type Server interface {
	libsrv.Server

	Info

	Handler(h srvtps.FuncHandler)
	Merge(s Server, def liblog.FuncLog) error

	GetConfig() *Config
	SetConfig(cfg Config, defLog liblog.FuncLog) error

	Monitor(vrs libver.Version) (montps.Monitor, error)
	MonitorName() string
}

func New

func New(cfg Config, defLog liblog.FuncLog) (Server, error)