run

Documentation

Index

• func SignalHandler(ctx context.Context, signals ...os.Signal) (execute func() error, interrupt func(error))
• type Group
  • func (g *Group) Add(execute func() error, interrupt func(error))
  • func (g *Group) Run() error
• type SignalError
  • func (e SignalError) Error() string

Examples

• Group.Add (Basic)
• Group.Add (Context)
• Group.Add (Listener)

Functions

func SignalHandler

func SignalHandler(ctx context.Context, signals ...os.Signal) (execute func() error, interrupt func(error))

SignalHandler returns a function that can be used to handle signals. that terminates with SignalError when the process receives one of the provides signals. or the parent context is canceled.

Types

type Group

type Group struct {
	// contains filtered or unexported fields
}

Group collects actors (functions) and runs them concurrently. When one actor returns an error, all actors are interrupted and the error is. The zero value of a Group is useful.

func (*Group) Add

func (g *Group) Add(execute func() error, interrupt func(error))

Add adds an actor to the group. Each actor must be pre-emptable by an interrupt function. That is, if interrupt is invoked, execute should return. Also, it must be safe to call interrupt even after execute has returned.

The first actor to return interrupts all running actors. The error os passed to the interrupt functions, and is returned by Run.

Example (Basic)

package main

import (
	"errors"
	"fmt"
	"time"

	"github.com/andrewbytecoder/gokit/run"
)

func main() {
	var g run.Group
	{
		cancel := make(chan struct{})
		g.Add(func() error {
			select {
			case <-time.After(time.Second):
				fmt.Printf("The first actor had its time elapsed\n")
				return nil
			case <-cancel:
				fmt.Printf("The first actor was canceled\n")
				return nil
			}
		}, func(err error) {
			fmt.Printf("The first actor was interrupted with: %v\n", err)
			close(cancel)
		})
	}
	{
		g.Add(func() error {
			fmt.Printf("The second actor is returning immediately\n")
			return errors.New("immediate teardown")
		}, func(err error) {
			// Note that this interrupt function is called, even though the
			// corresponding execute function has already returned.
			fmt.Printf("The second actor was interrupted with: %v\n", err)
		})
	}
	fmt.Printf("The group was terminated with: %v\n", g.Run())
}

Output:

The second actor is returning immediately
The first actor was interrupted with: immediate teardown
The second actor was interrupted with: immediate teardown
The first actor was canceled
The group was terminated with: immediate teardown

Example (Context)

package main

import (
	"context"
	"fmt"

	"github.com/andrewbytecoder/gokit/run"
)

func main() {
	ctx, cancel := context.WithCancel(context.Background())
	var g run.Group
	{
		ctx, cancel := context.WithCancel(ctx) // note: shadowed
		g.Add(func() error {
			return runUntilCanceled(ctx)
		}, func(error) {
			cancel()
		})
	}
	go cancel()
	fmt.Printf("The group was terminated with: %v\n", g.Run())
}

func runUntilCanceled(ctx context.Context) error {
	<-ctx.Done()
	return ctx.Err()
}

Output:

The group was terminated with: context canceled

Example (Listener)

package main

import (
	"errors"
	"fmt"
	"net"
	"net/http"

	"github.com/andrewbytecoder/gokit/run"
)

func main() {
	var g run.Group
	{
		ln, _ := net.Listen("tcp", ":0")
		g.Add(func() error {
			defer fmt.Printf("http.Serve returned\n")
			return http.Serve(ln, http.NewServeMux())
		}, func(error) {
			ln.Close()
		})
	}
	{
		g.Add(func() error {
			return errors.New("immediate teardown")
		}, func(error) {
			//
		})
	}
	fmt.Printf("The group was terminated with: %v\n", g.Run())
}

Output:

http.Serve returned
The group was terminated with: immediate teardown

func (*Group) Run

func (g *Group) Run() error

Run runs all actors concurrently. When the first actor returns, all actors are interrupted. Run only returns when all actors have exited. Run returns the error returned by the first exiting actor.

type SignalError

type SignalError struct {
	Single os.Signal
}

SignalError is an error that indicates that the process received a signal.

func (SignalError) Error

func (e SignalError) Error() string

Error implements the error interface.