import "code.gitea.io/gitea/modules/graceful"
context.go manager.go manager_unix.go net_unix.go restart_unix.go server.go server_hooks.go server_http.go
var (
ErrShutdown = fmt.Errorf("Graceful Manager called Shutdown")
ErrHammer = fmt.Errorf("Graceful Manager called Hammer")
ErrTerminate = fmt.Errorf("Graceful Manager called Terminate")
)Errors for context.Err()
var (
// DefaultReadTimeOut default read timeout
DefaultReadTimeOut time.Duration
// DefaultWriteTimeOut default write timeout
DefaultWriteTimeOut time.Duration
// DefaultMaxHeaderBytes default max header bytes
DefaultMaxHeaderBytes int
)CloseProvidedListeners closes all unused provided listeners.
GetListener obtains a listener for the local network address. The network must be a stream-oriented network: "tcp", "tcp4", "tcp6", "unix" or "unixpacket". It returns an provided net.Listener for the matching network and address, or creates a new one using net.Listen.
GetListenerTCP announces on the local network address. The network must be: "tcp", "tcp4" or "tcp6". It returns a provided net.Listener for the matching network and address, or creates a new one using net.ListenTCP.
GetListenerUnix announces on the local network address. The network must be: "unix" or "unixpacket". It returns a provided net.Listener for the matching network and address, or creates a new one using net.ListenUnix.
HTTPListenAndServe listens on the provided network address and then calls Serve to handle requests on incoming connections.
HTTPListenAndServeTLS listens on the provided network address and then calls Serve to handle requests on incoming connections.
func HTTPListenAndServeTLSConfig(network, address string, tlsConfig *tls.Config, handler http.Handler) error
HTTPListenAndServeTLSConfig listens on the provided network address and then calls Serve to handle requests on incoming connections.
InitManager creates the graceful manager in the provided context
func KillParent()
KillParent sends the kill signal to the parent process if we are a child
RestartProcess starts a new process passing it the active listeners. It doesn't fork, but starts a new process using the same environment and arguments as when it was originally started. This allows for a newly deployed binary to be started. It returns the pid of the newly started process when successful.
CallbackWithContext is combined runnable and context to watch to see if the caller has finished
type ChannelContext struct {
// contains filtered or unexported fields
}ChannelContext is a context that wraps a channel and error as a context
func NewChannelContext(done <-chan struct{}, err error) *ChannelContextNewChannelContext creates a ChannelContext from a channel and error
func (ctx *ChannelContext) Deadline() (deadline time.Time, ok bool)
Deadline returns the time when work done on behalf of this context should be canceled. There is no Deadline for a ChannelContext
func (ctx *ChannelContext) Done() <-chan struct{}
Done returns the channel provided at the creation of this context. When closed, work done on behalf of this context should be canceled.
func (ctx *ChannelContext) Err() error
Err returns nil, if Done is not closed. If Done is closed, Err returns the error provided at the creation of this context
func (ctx *ChannelContext) Value(key interface{}) interface{}
Value returns nil for all calls as no values are or can be associated with this context
type Manager struct {
// contains filtered or unexported fields
}Manager manages the graceful shutdown process
GetManager returns the Manager
Deadline returns nil as there is no fixed Deadline for the manager, it allows the manager to be viewed as a context.Context
DoGracefulRestart causes a graceful restart
DoGracefulShutdown causes a graceful shutdown
DoImmediateHammer causes an immediate hammer
Done allows the manager to be viewed as a context.Context, it returns a channel that is closed when the server is finished terminating
Err allows the manager to be viewed as a context.Context done at Terminate, it returns ErrTerminate
HammerContext returns a context.Context that is Done at hammer Callers using this context should ensure that they are registered as a running server in order that they are waited for.
InformCleanup tells the cleanup wait group that we have either taken a listener or will not be taking a listener
IsChild returns if the current process is a child of previous Gitea process
IsHammer returns a channel which will be closed at hammer The order of closure is IsShutdown, IsHammer (potentially), IsTerminate Servers running within the running server wait group should respond to IsHammer if not shutdown already
IsShutdown returns a channel which will be closed at shutdown. The order of closure is IsShutdown, IsHammer (potentially), IsTerminate
IsTerminate returns a channel which will be closed at terminate The order of closure is IsShutdown, IsHammer (potentially), IsTerminate IsTerminate will only close once all running servers have stopped
RegisterServer registers the running of a listening server, in the case of unix this means that the parent process can now die. Any call to RegisterServer must be matched by a call to ServerDone
RunAtHammer creates a go-routine to run the provided function at shutdown
RunAtShutdown creates a go-routine to run the provided function at shutdown
RunAtTerminate adds to the terminate wait group and creates a go-routine to run the provided function at termination
func (g *Manager) RunWithShutdownChan(run RunnableWithShutdownChan)
RunWithShutdownChan takes a function that has channel to watch for shutdown and atTerminate callbacks After the atShutdown channel is closed, the main function must return once shutdown is complete. (Optionally IsHammer may be waited for instead however, this should be avoided if possible.) The callback function provided to atTerminate must return once termination is complete. Please note that use of the atTerminate function will create a go-routine that will wait till terminate - users must therefore be careful to only call this as necessary.
RunWithShutdownContext takes a function that has a context to watch for shutdown. After the provided context is Done(), the main function must return once shutdown is complete. (Optionally the HammerContext may be obtained and waited for however, this should be avoided if possible.)
func (g *Manager) RunWithShutdownFns(run RunnableWithShutdownFns)
RunWithShutdownFns takes a function that has both atShutdown and atTerminate callbacks After the callback to atShutdown is called and is complete, the main function must return. Similarly the callback function provided to atTerminate must return once termination is complete. Please note that use of the atShutdown and atTerminate callbacks will create go-routines that will wait till their respective signals - users must therefore be careful to only call these as necessary. If run is not expected to run indefinitely RunWithShutdownChan is likely to be more appropriate.
ServerDone declares a running server done and subtracts one from the running server wait group. Users probably do not want to call this and should use one of the RunWithShutdown* functions
ShutdownContext returns a context.Context that is Done at shutdown Callers using this context should ensure that they are registered as a running server in order that they are waited for.
TerminateContext returns a context.Context that is Done at terminate Callers using this context should ensure that they are registered as a terminating server in order that they are waited for.
Value allows the manager to be viewed as a context.Context done at Terminate, it has no values
WaitForServers waits for all running servers to finish. Users should probably instead use AtTerminate or IsTerminate
WaitForTerminate waits for all terminating actions to finish. Only the main go-routine should use this
type RunnableWithShutdownChan func(atShutdown <-chan struct{}, atTerminate CallbackWithContext)RunnableWithShutdownChan is a runnable with functions to run at shutdown and terminate. After the atShutdown channel is closed, the main function must return once shutdown is complete. (Optionally IsHammer may be waited for instead however, this should be avoided if possible.) The callback function provided to atTerminate must return once termination is complete. Please note that use of the atTerminate function will create a go-routine that will wait till terminate - users must therefore be careful to only call this as necessary.
RunnableWithShutdownFns is a runnable with functions to run at shutdown and terminate After the callback to atShutdown is called and is complete, the main function must return. Similarly the callback function provided to atTerminate must return once termination is complete. Please note that use of the atShutdown and atTerminate callbacks will create go-routines that will wait till their respective signals - users must therefore be careful to only call these as necessary. If run is not expected to run indefinitely RunWithShutdownChan is likely to be more appropriate.
ServeFunction represents a listen.Accept loop
type Server struct {
BeforeBegin func(network, address string)
OnShutdown func()
// contains filtered or unexported fields
}Server represents our graceful server
NewServer creates a server on network at provided address
func (srv *Server) ListenAndServe(serve ServeFunction) error
ListenAndServe listens on the provided network address and then calls Serve to handle requests on incoming connections.
func (srv *Server) ListenAndServeTLS(certFile, keyFile string, serve ServeFunction) error
ListenAndServeTLS listens on the provided network address and then calls Serve to handle requests on incoming TLS connections.
Filenames containing a certificate and matching private key for the server must be provided. If the certificate is signed by a certificate authority, the certFile should be the concatenation of the server's certificate followed by the CA's certificate.
ListenAndServeTLSConfig listens on the provided network address and then calls Serve to handle requests on incoming TLS connections.
func (srv *Server) Serve(serve ServeFunction) error
Serve accepts incoming HTTP connections on the wrapped listener l, creating a new service goroutine for each. The service goroutines read requests and then call handler to reply to them. Handler is typically nil, in which case the DefaultServeMux is used.
In addition to the standard Serve behaviour each connection is added to a sync.Waitgroup so that all outstanding connections can be served before shutting down the server.
Package graceful imports 21 packages (graph) and is imported by 59 packages. Updated 2021-01-22. Refresh now. Tools for package owners.