Version: v0.7.0 Latest Latest

This package is not in the latest version of its module.

Go to latest
Published: Dec 22, 2014 License: MIT, Apache-2.0 Imports: 8 Imported by: 0



A polite webserver for Go.

Manners allows you to shut your Go webserver down gracefully, without dropping any requests. It can act as a drop-in replacement for the standard library's http.ListenAndServe function:

func main() {
  handler := MyHTTPHandler()
  manners.ListenAndServe(":7000", handler)

Then, when you want to shut the server down:


(Note that this does not block until all the requests are finished. Rather, the call to manners.ListenAndServe will stop blocking when all the requests are finished.)

Manners ensures that all requests are served by incrementing a WaitGroup when a request comes in and decrementing it when the request finishes.

If your request handler spawns Goroutines that are not guaranteed to finish with the request, you can ensure they are also completed with the StartRoutine and FinishRoutine functions on the server.


Manners 0.3.0 and above uses standard library functionality introduced in Go 1.3.


go get



Package manners provides a wrapper for a standard net/http server that ensures all active HTTP client have completed their current request before the server shuts down.

It can be used a drop-in replacement for the standard http package, or can wrap a pre-configured Server.


myHandler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {

http.Handle("/hello", myHandler)

log.Fatal(manners.ListenAndServe(":8080", nil))

or for a customized server:

s := manners.NewWithServer(&http.Server{
	Addr:           ":8080",
	Handler:        myHandler,
	ReadTimeout:    10 * time.Second,
	WriteTimeout:   10 * time.Second,
	MaxHeaderBytes: 1 << 20,

The server will shutdown cleanly when the Close() method is called:

go func() {
	sigchan := make(chan os.Signal, 1)
	signal.Notify(sigchan, os.Interrupt, os.Kill)
	log.Info("Shutting down...")

http.Handle("/hello", myHandler)
log.Fatal(manners.ListenAndServe(":8080", nil))



This section is empty.


This section is empty.


func Close

func Close()

Close triggers a shutdown of all running Graceful servers.

func ListenAndServe

func ListenAndServe(addr string, handler http.Handler) error

ListenAndServe provides a graceful version of function provided by the net/http package.

func ListenAndServeTLS

func ListenAndServeTLS(addr string, certFile string, keyFile string, handler http.Handler) error

ListenAndServeTLS provides a graceful version of function provided by the net/http package.

func NewTLSListener

func NewTLSListener(inner net.Listener, config *tls.Config) net.Listener

NewListener creates a Listener which accepts connections from an inner Listener and wraps each connection with Server. The configuration config must be non-nil and must have at least one certificate.

func Serve

func Serve(l net.Listener, handler http.Handler) error

Serve provides a graceful version of function provided by the net/http package.


type GracefulListener

type GracefulListener struct {
	// contains filtered or unexported fields

A GracefulListener differs from a standard net.Listener in one way: if Accept() is called after it is gracefully closed, it returns a listenerAlreadyClosed error. The GracefulServer will ignore this error.

func NewListener

func NewListener(l net.Listener) *GracefulListener

NewListener wraps an existing listener for use with GracefulServer.

Note that you generally don't need to use this directly as GracefulServer will automatically wrap any non-graceful listeners supplied to it.

func (*GracefulListener) Accept

func (l *GracefulListener) Accept() (net.Conn, error)

Accept implements the Accept method in the Listener interface.

func (*GracefulListener) Addr

func (l *GracefulListener) Addr() net.Addr

func (*GracefulListener) Clone

func (l *GracefulListener) Clone() (net.Listener, error)

func (*GracefulListener) Close

func (l *GracefulListener) Close() error

Close tells the wrapped listener to stop listening. It is idempotent.

func (*GracefulListener) GetFile

func (l *GracefulListener) GetFile() (*os.File, error)

type GracefulServer

type GracefulServer struct {
	// contains filtered or unexported fields

A GracefulServer maintains a WaitGroup that counts how many in-flight requests the server is handling. When it receives a shutdown signal, it stops accepting new requests but does not actually shut down until all in-flight requests terminate.

GracefulServer embeds the underlying net/http.Server making its non-override methods and properties avaiable.

It must be initialized by calling NewServer or NewWithServer

func NewServer

func NewServer() *GracefulServer

NewServer creates a new GracefulServer. The server will begin shutting down when a value is passed to the Shutdown channel.

func NewWithOptions

func NewWithOptions(o Options) *GracefulServer

func NewWithServer

func NewWithServer(s *http.Server) *GracefulServer

NewWithServer wraps an existing http.Server object and returns a GracefulServer that supports all of the original Server operations.

func (*GracefulServer) Close

func (s *GracefulServer) Close()

Close stops the server from accepting new requets and beings shutting down.

func (*GracefulServer) FinishRoutine

func (s *GracefulServer) FinishRoutine()

FinishRoutine decrements the server's WaitGroup. Used this to complement StartRoutine().

func (*GracefulServer) GetFile

func (gs *GracefulServer) GetFile() (*os.File, error)

func (*GracefulServer) HijackListener

func (gs *GracefulServer) HijackListener(s *http.Server, config *tls.Config) (*GracefulServer, error)

func (*GracefulServer) ListenAndServe

func (s *GracefulServer) ListenAndServe() error

ListenAndServe provides a graceful equivalent of net/http.Serve.ListenAndServe.

func (*GracefulServer) ListenAndServeTLS

func (s *GracefulServer) ListenAndServeTLS(certFile, keyFile string) error

ListenAndServeTLS provides a graceful equivalent of net/http.Serve.ListenAndServeTLS.

func (*GracefulServer) ListenAndServeTLSWithConfig

func (s *GracefulServer) ListenAndServeTLSWithConfig(config *tls.Config) error

ListenAndServeTLS provides a graceful equivalent of net/http.Serve.ListenAndServeTLS.

func (*GracefulServer) Serve

func (s *GracefulServer) Serve(listener net.Listener) error

Serve provides a graceful equivalent net/http.Server.Serve.

If listener is not an instance of *GracefulListener is will be wrapped to become one.

func (*GracefulServer) StartRoutine

func (s *GracefulServer) StartRoutine()

StartRoutine increments the server's WaitGroup. Use this if a web request starts more goroutines and these goroutines are not guaranteed to finish before the request.

type Options

type Options struct {
	Server       *http.Server
	StateHandler StateHandler
	Listener     net.Listener

type StateHandler

type StateHandler func(net.Conn, http.ConnState, http.ConnState)

StateHandler can be called by the server if the state of the connection changes. Notice that it passed previous state and the new state as parameters.

type TCPKeepAliveListener

type TCPKeepAliveListener struct {

TCPKeepAliveListener sets TCP keep-alive timeouts on accepted connections. It's used by ListenAndServe and ListenAndServeTLS so dead TCP connections (e.g. closing laptop mid-download) eventually go away.

direct lift from net/http/server.go

func (TCPKeepAliveListener) Accept

func (ln TCPKeepAliveListener) Accept() (c net.Conn, err error)

type TLSListener

type TLSListener struct {
	// contains filtered or unexported fields

A listener implements a network listener (net.Listener) for TLS connections. direct lift from crypto/tls.go

func (*TLSListener) Accept

func (l *TLSListener) Accept() (c net.Conn, err error)

Accept waits for and returns the next incoming TLS connection. The returned connection c is a *tls.Conn.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL