README
¶
An exit strategy for go routines.
The library helps to end the go routines in your program and collects potential errors.
Install
go get github.com/simia-tech/go-exit
Example (main)
func main() {
exit.Main.SetTimeout(2 * time.Second)
counterExitSignal := exit.Main.NewSignal("counter")
go func() {
counter := 0
var reply exit.Reply
for reply == nil {
select {
case reply = <-counterExitSignal.Chan:
break
case <-time.After(1 * time.Second):
counter++
fmt.Printf("%d ", counter)
}
}
switch {
case counter%5 == 0:
// Don't send a return via reply to simulate
// an infinite running go routine. The timeout
// should be hit in this case.
case counter%2 == 1:
reply.Err(fmt.Errorf("exit on the odd counter %d", counter))
default:
reply.Ok()
}
}()
if report := exit.Main.ExitOn(syscall.SIGINT); report != nil {
fmt.Println()
report.WriteTo(os.Stderr)
os.Exit(-1)
}
fmt.Println()
}
The default exit exit.Main should be used by the main program to exit it's go routines. If go-exit is used
in a library, a separate exit should be created and used to end the library's go routines. This way the library
stays independent from other exit code.
Example (library)
type Server struct {
Address string
exit *exit.Exit
}
func New(address string) *Server {
return &Server{
Address: address,
exit: exit.New("server"),
}
}
func (s *Server) Open() error {
listener, err := net.Listen("tcp", s.Address)
if err != nil {
return err
}
signal := s.exit.NewSignal("acceptor")
go func() {
var reply exit.Reply
go func() {
for {
connection, err := listener.Accept()
if err != nil {
if reply != nil && strings.Contains(
err.Error(), "closed network connection") {
reply.Ok()
} else {
reply.Err(err)
}
return
}
log.Printf("connected %v", connection.RemoteAddr())
// handle connection
}
}()
reply = <-signal.Chan
if err := listener.Close(); err != nil {
reply.Err(err)
}
}()
return nil
}
func (s *Server) Close() error {
if report := s.exit.Exit(); report != nil {
return report
}
return nil
}
License
The project is licensed under Apache 2.0.
Documentation
¶
Index ¶
Constants ¶
This section is empty.
Variables ¶
var (
ErrTimeout = errors.New("timeout")
)
Defines errors.
var Main = New("main")
Main defines the main exit. This exit should be used by the main program. Libraries should create their own exit.
Functions ¶
This section is empty.
Types ¶
type Exit ¶
type Exit struct {
Name string
// contains filtered or unexported fields
}
Exit defines an exit that contains multiple SignalChans.
func (*Exit) AfterAll ¶
AfterAll registers a callback function that is called after all actors has exited.
func (*Exit) AfterEach ¶
AfterEach registers a callback function that is called after each actor that has exited.
func (*Exit) Exit ¶
Exit sends an ErrChan through all the previously generated SignalChans and waits until all returned an error or nil. The received errors will be returned in an error report.
func (*Exit) ExitOn ¶
ExitOn blocks until the process receives one of the provided signals and than calls Exit.
func (*Exit) HasTimeout ¶
HasTimeout returns true if a timeout is set.
func (*Exit) SetTimeout ¶
SetTimeout sets a timeout for the actors to end during the exit process.
type Reply ¶
type Reply chan error
Reply defines a channel of errors that can be used to deliver back an error after an actor has shut down.
type Report ¶
type Report struct {
ExitName string
// contains filtered or unexported fields
}
Report defines the report of the exit process. It contains map of all signal names with their returned error.
type Signal ¶
Signal defines an exit signal signal for a single actor.
func (*Signal) AfterExit ¶
AfterExit registers a callback function that is called after the exit has been performed.
func (*Signal) HasTimeout ¶
HasTimeout returns true if a timeout is set.
func (*Signal) SetTimeout ¶
SetTimeout sets the timeout for this specific exit signal to complete. If no or zero timeout is set, the exit process can last forever.
Source Files
Directories