package proc

import "k8s.io/kubernetes/contrib/mesos/pkg/proc"

Package proc provides opinionated utilities for processing background operations and future errors, somewhat inspired by libprocess.

Index ¶

• func ErrorChan(err error) <-chan error
• func ErrorChanf(msg string, args ...interface{}) <-chan error
• func IsIllegalState(err error) bool
• func IsProcessTerminated(err error) bool
• func OnError(ch <-chan error, f func(error), abort <-chan struct{}) <-chan struct{}
• type Action
• type Config
• type Context
• type Doer
• type DoerFunc
• func (f DoerFunc) Do(a Action) <-chan error
• type ErrorOnce
• func NewErrorOnce(abort <-chan struct{}) ErrorOnce
• type Process
• func DoWith(other Process, d Doer) Process
• func New() Process

Functions ¶

func ErrorChan ¶

func ErrorChan(err error) <-chan error

ErrorChan is a convenience func that returns a chan that yields the given error. If err is nil then a closed chan is returned.

func ErrorChanf ¶

func ErrorChanf(msg string, args ...interface{}) <-chan error

ErrorChanf is a convenience func that returns a chan that yields an error generated from the given msg format and args.

func IsIllegalState ¶

func IsIllegalState(err error) bool

func IsProcessTerminated ¶

func IsProcessTerminated(err error) bool

func OnError ¶

func OnError(ch <-chan error, f func(error), abort <-chan struct{}) <-chan struct{}

OnError spawns a goroutine that waits for an error. if a non-nil error is read from the channel then the handler func is invoked, otherwise (nil error or closed chan) the handler is skipped. if a nil handler is specified then it's not invoked. the signal chan that's returned closes once the error process logic (and handler, if any) has completed.

Types ¶

type Action ¶

type Action func()

Action is something that executes in the context of a process

type Config ¶

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

type Context ¶

type Context interface {
	// end (terminate) the execution context
	End() <-chan struct{}

	// return a signal chan that will close upon the termination of this process
	Done() <-chan struct{}
}

type Doer ¶

type Doer interface {
	// execute some action in some context. actions are to be executed in a
	// concurrency-safe manner: no two actions should execute at the same time.
	// errors are generated if the action cannot be executed (not by the execution
	// of the action) and should be testable with the error API of this package,
	// for example, IsProcessTerminated.
	Do(Action) <-chan error
}

type DoerFunc ¶

type DoerFunc func(Action) <-chan error

DoerFunc is an adapter func for Doer interface

func (DoerFunc) Do ¶

func (f DoerFunc) Do(a Action) <-chan error

invoke the f on action a. returns an illegal state error if f is nil.

type ErrorOnce ¶

type ErrorOnce interface {
	// Err returns a chan that only ever sends one error, either obtained via Report() or Forward().
	Err() <-chan error

	// Report reports the given error via Err(), but only if no other errors have been reported or forwarded.
	Report(error)

	// Report reports an error via Err(), but only if no other errors have been reported or forwarded, using
	// fmt.Errorf to generate the error.
	Reportf(string, ...interface{})

	// Send is non-blocking; it spins up a goroutine that reports an error (if any) that occurs on the error chan.
	Send(<-chan error) ErrorOnce

	// WaitFor returns true if an error is received within the specified duration, otherwise false
	WaitFor(time.Duration) (error, bool)
	// contains filtered or unexported methods
}

ErrorOnce an error promise. If we ever start building out support for other promise types it will probably make sense to group them in some sort of "promises" package.

func NewErrorOnce ¶

func NewErrorOnce(abort <-chan struct{}) ErrorOnce

NewErrorOnce creates an ErrorOnce that aborts blocking func calls once the given abort chan has closed.

type Process ¶

type Process interface {
	Context
	Doer

	// see top level OnError func. this implementation will terminate upon the arrival of
	// an error (and subsequently invoke the error handler, if given) or else the termination
	// of the process (testable via IsProcessTerminated).
	OnError(<-chan error, func(error)) <-chan struct{}

	// return a signal chan that will close once the process is ready to run actions
	Running() <-chan struct{}
}

func DoWith ¶

func DoWith(other Process, d Doer) Process

DoWith returns a process that, within its execution context, delegates to the specified Doer. Expect a panic if either the given Process or Doer are nil.

func New ¶

func New() Process

Source Files ¶

adapter.go doc.go errors.go once.go proc.go state.go types.go