container

type Factory func() (Runnable, error)

type ID string

type Monitor interface {
	Spawned(runnable Runnable, id ID)
	Stopped(runnable Runnable, id ID, err error)
}

type MonitorEventEmitter struct {
	MonitorEvents // Implements listener operations
	// contains filtered or unexported fields
}

type MonitorEvents interface {
	// Spawned adds event listener for event 'Spawned'
	OnSpawned(handler MonitorSpawnedHandlerFunc)

	// NoSpawned excludes event listener
	NoSpawned(handler MonitorSpawnedHandlerFunc)

	// Stopped adds event listener for event 'Stopped'
	OnStopped(handler MonitorStoppedHandlerFunc)

	// NoStopped excludes event listener
	NoStopped(handler MonitorStoppedHandlerFunc)

	// AddHandler adds handler for events (Spawned, Stopped)
	AddHandler(handler Monitor)

	// RemoveHandler remove handler for events
	RemoveHandler(handler Monitor)
}

type MonitorSpawnedHandlerFunc func(runnable Runnable, id ID) // Listener handler function for event 'Spawned'

type MonitorStoppedHandlerFunc func(runnable Runnable, id ID, err error) // Listener handler function for event 'Stopped'

type Runnable interface {
	Label() string
	Run(ctx context.Context) error
}

type RunnableInfo struct {
	Instance Runnable
	ID       ID
}

type Supervisor interface {
	// Watch runnable and restart if needed but not more then restartLimit. If restartLimit is negative, it's mean infinity.
	// If runnable stopped with error and stopOnError is true, then watch loop exits.
	// Events MUST be consumed
	Watch(ctx context.Context, factory Factory, restartLimit int, restartDelay time.Duration, stopOnError bool) WatchEvents
	// Spawn and monitor one runnable in background. Returns generated ID, done channel (buffered) and stop function
	Spawn(runnable Runnable) (ID, <-chan error, func())
	// SpawnFunc creates and spawn ClosureWrapper runnable
	SpawnFunc(label string, closure func(ctx context.Context) error) (ID, <-chan error, func())
	// List all runnables
	List() []RunnableInfo
	// Get runnable by generated ID
	Get(ID) Runnable
	// Events emitter of runnable
	Events() MonitorEvents
	// Close supervisor and stops all processes
	Close()
}

type WatchEventStarted RunnableInfo

type WatchEventStopped struct {
	RunnableInfo
	Error error
}

type WatchEvents <-chan interface{}