package rutina
import (
"context"
"os"
"time"
)
type Options struct {
ParentContext context.Context
ListenOsSignals []os.Signal
Logger func(format string, v ...interface{})
Errors chan error
}
func ParentContext(ctx context.Context) Options {
return Options{
ParentContext: ctx,
}
}
func ListenOsSignals(signals ...os.Signal) Options {
return Options{
ListenOsSignals: signals,
}
}
func Logger(l logger) Options {
return Options{
Logger: l,
}
}
func Errors(errCh chan error) Options {
return Options{
Errors: errCh,
}
}
func composeOptions(opts []Options) Options {
res := Options{
ParentContext: context.Background(),
Logger: nopLogger,
ListenOsSignals: []os.Signal{},
}
for _, o := range opts {
if o.ParentContext != nil {
res.ParentContext = o.ParentContext
}
if o.Errors != nil {
res.Errors = o.Errors
}
if o.ListenOsSignals != nil {
res.ListenOsSignals = o.ListenOsSignals
}
if o.Logger != nil {
res.Logger = o.Logger
}
}
return res
}
type Policy int
const (
DoNothing Policy = iota
Shutdown
Restart
)
type RunOptions struct {
OnDone Policy
OnError Policy
Timeout *time.Duration
MaxCount *int
}
func OnDone(policy Policy) RunOptions {
return RunOptions{
OnDone: policy,
}
}
func OnError(policy Policy) RunOptions {
return RunOptions{
OnError: policy,
}
}
func Timeout(timeout time.Duration) RunOptions {
return RunOptions{
Timeout: &timeout,
}
}
func MaxCount(maxCount int) RunOptions {
return RunOptions{
MaxCount: &maxCount,
}
}
func composeRunOptions(opts []RunOptions) RunOptions {
res := RunOptions{
OnDone: Shutdown,
OnError: Shutdown,
}
for _, o := range opts {
if o.OnDone != res.OnDone {
res.OnDone = o.OnDone
}
if o.OnError != res.OnError {
res.OnError = o.OnError
}
if o.MaxCount != nil {
res.MaxCount = o.MaxCount
}
if o.Timeout != nil {
res.Timeout = o.Timeout
}
}
return res
}
