prefork

Documentation

Index

• Variables
• func IsChild() bool
• type Logger
• type Prefork
  • func New(s *fasthttp.Server, workerCount int) *Prefork
  • func (p *Prefork) ListenAndServe(addr string) error
  • func (p *Prefork) ListenAndServeTLS(addr, certKey, certFile string) error
  • func (p *Prefork) ListenAndServeTLSEmbed(addr string, certData, keyData []byte) error

Variables

var (

	// ErrOverRecovery is returned when the times of starting over child prefork processes exceed
	// the threshold.
	ErrOverRecovery           = errors.New("exceeding the value of RecoverThreshold")
	ErrOnlyReuseportOnWindows = errors.New("windows only supports Reuseport = true")
)

Functions

func IsChild

func IsChild() bool

IsChild checks if the current thread/process is a child

Types

type Logger

type Logger interface {
	// Printf must have the same semantics as log.Printf.
	Printf(format string, args ...interface{})
}

Logger is used for logging formatted messages.

type Prefork

type Prefork struct {
	// The network must be "tcp", "tcp4" or "tcp6".
	//
	// By default is "tcp4"
	Network string

	// The amount of worker processes to start
	WorkerCount int

	// Flag to use a listener with reuseport, if not a file Listener will be used
	// See: https://www.nginx.com/blog/socket-sharding-nginx-release-1-9-1/
	//
	// It's disabled by default
	Reuseport bool

	// Child prefork processes may exit with failure and will be started over until the times reach
	// the value of RecoverThreshold, then it will return and terminate the server.
	RecoverThreshold int

	// By default standard logger from log package is used.
	Logger Logger

	ServeFunc         func(ln net.Listener) error
	ServeTLSFunc      func(ln net.Listener, certFile, keyFile string) error
	ServeTLSEmbedFunc func(ln net.Listener, certData, keyData []byte) error
	// contains filtered or unexported fields
}

Prefork implements fasthttp server prefork

Preforks master process (with all cores) between several child processes increases performance significantly, because Go doesn't have to share and manage memory between cores

WARNING: using prefork prevents the use of any global state! Things like in-memory caches won't work.

func New

func New(s *fasthttp.Server, workerCount int) *Prefork

New wraps the fasthttp server to run with preforked processes

func (*Prefork) ListenAndServe

func (p *Prefork) ListenAndServe(addr string) error

ListenAndServe serves HTTP requests from the given TCP addr

func (*Prefork) ListenAndServeTLS

func (p *Prefork) ListenAndServeTLS(addr, certKey, certFile string) error

ListenAndServeTLS serves HTTPS requests from the given TCP addr

certFile and keyFile are paths to TLS certificate and key files.

func (*Prefork) ListenAndServeTLSEmbed

func (p *Prefork) ListenAndServeTLSEmbed(addr string, certData, keyData []byte) error

ListenAndServeTLSEmbed serves HTTPS requests from the given TCP addr

certData and keyData must contain valid TLS certificate and key data.