Documentation ¶
Overview ¶
Package daemon for the run job background and manage them.
Index ¶
- func DelayJob(d time.Duration, err error) error
- func GetDelayedJob(err error) (time.Duration, bool)
- func IsStoppedJob(err error) bool
- func StopJob(err error) error
- type Handle
- type Job
- type Manager
- type Option
- func Retry(max uint8, handleRetry func(err error) error) Option
- func RunOnce() Option
- func WithDelay(delay time.Duration) Option
- func WithFreq(freq time.Duration) Option
- func WithHandleErr(fn func(error)) Option
- func WithName(name string) Option
- func WithRunMiddleware(fn ...Handle) Option
- func WithSchedule(next func(time.Time) time.Duration) Option
- func WithStop(stop Run) Option
- func WithStopMiddleware(fn ...Handle) Option
- func WithTimer(timer Timer) Option
- type Run
- type Timer
Examples ¶
Constants ¶
This section is empty.
Variables ¶
This section is empty.
Functions ¶
func GetDelayedJob ¶
GetDelayedJob get delay job.
Types ¶
type Job ¶
type Job struct {
// contains filtered or unexported fields
}
Job run job by frequency.
Example (Delay) ¶
package main import ( "context" "errors" "fmt" "sync/atomic" "time" "gitoa.ru/go-4devs/daemon" ) var ErrJob = errors.New("some reason") func main() { var i int32 ctx, cancel := context.WithTimeout(context.Background(), time.Second) defer cancel() m := daemon.New() j := daemon.NewJob(func(ctx context.Context) error { if i == 3 { return daemon.StopJob(nil) } atomic.AddInt32(&i, 1) fmt.Print("do some:", i, " ") return daemon.DelayJob(time.Second/2, ErrJob) }) m.Do(ctx, j) m.Wait() }
Output: do some:1 do some:2 do some:3
Example (Option) ¶
package main import ( "context" "fmt" "sync/atomic" "time" "gitoa.ru/go-4devs/daemon" ) func main() { var cnt int32 ctx, cancel := context.WithTimeout(context.TODO(), time.Second) defer cancel() m := daemon.New() j := daemon.NewJob(func(ctx context.Context) error { if cnt == 2 { return daemon.StopJob(nil) } atomic.AddInt32(&cnt, 1) fmt.Println("do some") return nil }, // set freq run job daemon.WithFreq(time.Microsecond), // set delay to start job daemon.WithDelay(time.Nanosecond), ) m.Do(ctx, j) m.Wait() }
Output: do some do some
Example (WithMiddleware) ¶
package main import ( "context" "fmt" "time" "gitoa.ru/go-4devs/daemon" ) func main() { ctx, cancel := context.WithTimeout(context.Background(), time.Second) defer cancel() m := daemon.New() j := daemon.NewJob( func(ctx context.Context) error { fmt.Println("do some job;") return daemon.StopJob(nil) }, daemon.WithStop(func(ctx context.Context) error { fmt.Println("do some close job;") return nil }), daemon.WithRunMiddleware(func(ctx context.Context, next daemon.Run) error { fmt.Println("do some before run func;") err := next(ctx) fmt.Println("do some after run func;") return err }), daemon.WithStopMiddleware(func(ctx context.Context, next daemon.Run) error { fmt.Println("do some before close func;") err := next(ctx) fmt.Println("do some after close func;") return err }), ) m.Do(ctx, j) m.Wait() }
Output: do some before run func; do some job; do some after run func; do some before close func; do some close job; do some after close func;
func NewJob ¶
NewJob creates new job.
Example ¶
package main import ( "context" "fmt" "gitoa.ru/go-4devs/daemon" ) func main() { ctx := context.Background() m := daemon.New(func(j *daemon.Job) { daemon.WithRunMiddleware(func(ctx context.Context, next daemon.Run) error { fmt.Printf("running job: %s\n", j) return daemon.StopJob(next(ctx)) })(j) }) j := daemon.NewJob(func(ctx context.Context) error { // do some return nil }, daemon.WithName("my awesome job")) m.Do(ctx, j) m.Wait() }
Output: running job: my awesome job
Example (Stop) ¶
package main import ( "context" "errors" "fmt" "sync/atomic" "time" "gitoa.ru/go-4devs/daemon" ) var ErrJob = errors.New("some reason") func main() { ctx, cancel := context.WithTimeout(context.Background(), time.Second) defer cancel() m := daemon.New() var i int32 j := daemon.NewJob(func(ctx context.Context) error { atomic.AddInt32(&i, 1) fmt.Print("do some:", i, " ") return daemon.StopJob(ErrJob) }) m.Do(ctx, j) m.Wait() }
Output: do some:1
Example (WithClose) ¶
package main import ( "context" "fmt" "time" "gitoa.ru/go-4devs/daemon" ) func main() { ctx, cancel := context.WithTimeout(context.Background(), time.Second) defer cancel() m := daemon.New() j := daemon.NewJob(func(ctx context.Context) error { fmt.Println("do some long job;") return daemon.StopJob(nil) }, daemon.WithStop(func(ctx context.Context) error { fmt.Println("do some close job;") return nil })) m.Do(ctx, j) m.Wait() }
Output: do some long job; do some close job;
type Manager ¶
Manager run jobs.
Example ¶
package main import ( "context" "log" "time" "gitoa.ru/go-4devs/daemon" ) func main() { m := daemon.New() j := daemon.NewJob(func(ctx context.Context) error { // do some job return daemon.StopJob(nil) }, daemon.WithName("awesome job")) m.Do(context.Background(), j, // set frequency run job daemon.WithFreq(time.Minute), // set delay for first run job daemon.WithDelay(time.Second), // set handler if run job return err daemon.WithHandleErr(func(err error) { log.Println(err) }), ) m.Wait() }
Output:
Example (WithClose) ¶
package main import ( "context" "fmt" "time" "gitoa.ru/go-4devs/daemon" ) func main() { m := daemon.New() defer func() { _ = m.Close() }() j := daemon.NewJob(func(ctx context.Context) error { fmt.Println("do some job;") return daemon.StopJob(nil) }, daemon.WithName("awesome job")) m.Do(context.Background(), j, daemon.WithFreq(time.Microsecond)) // some blocked process time.Sleep(time.Second) }
Output: do some job;
Example (WithOptions) ¶
package main import ( "context" "fmt" "log" "time" "gitoa.ru/go-4devs/daemon" ) func main() { ctx := context.Background() middlewareRun := func(ctx context.Context, next daemon.Run) error { fmt.Println("do some before run all job;") err := next(ctx) fmt.Println("do some after run all job;") return err } middlewareStop := func(ctx context.Context, next daemon.Run) error { fmt.Println("do some before close all job;") err := next(ctx) fmt.Println("do some after close all job;") return err } m := daemon.New( daemon.WithRunMiddleware(middlewareRun), daemon.WithStopMiddleware(middlewareStop), daemon.WithHandleErr(func(err error) { // do some if close return err log.Println(err) }), ) j := daemon.NewJob(func(ctx context.Context) error { fmt.Println("do some job;") return daemon.StopJob(nil) }, daemon.WithName("awesome job")) j2 := daemon.NewJob(func(ctx context.Context) error { fmt.Println("do some job2;") return daemon.StopJob(nil) }, daemon.WithName("awesome job2")) m.Do(ctx, j, daemon.WithFreq(time.Minute), daemon.WithDelay(time.Second)) m.Do(ctx, j2, daemon.WithFreq(time.Nanosecond)) m.Wait() }
Output: do some before run all job; do some job2; do some after run all job; do some before close all job; do some after close all job; do some before run all job; do some job; do some after run all job; do some before close all job; do some after close all job;
type Option ¶
type Option func(*Job)
Option configure job.
func WithRunMiddleware ¶
WithRunMiddleware added middleware for the run job.
func WithSchedule ¶
WithSchedule set delay and frequency Run job.
func WithStopMiddleware ¶
WithStopMiddleware added middleware for the stop job.
Click to show internal directories.
Click to hide internal directories.