daemon

package module
v0.0.0-...-e80be6c Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Apr 26, 2021 License: MIT Imports: 7 Imported by: 0

README

daemon

Build Status Go Report Card GoDoc

Documentation

Overview

Package daemon for the run job background and manage them.

Index

Examples

Constants

This section is empty.

Variables

This section is empty.

Functions

func DelayJob 

func DelayJob(d time.Duration, err error) error

DelayJob update delay next Run job.

func GetDelayedJob 

func GetDelayedJob(err error) (time.Duration, bool)

GetDelayedJob get delay job.

func IsStoppedJob 

func IsStoppedJob(err error) bool

IsStoppedJob check stopped job.

func StopJob 

func StopJob(err error) error

StopJob stop job.

Types

type Handle 

type Handle func(ctx context.Context, next Run) error

Handle middleware interface.

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 

func NewJob(run Run, opts ...Option) *Job

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;

func (*Job) Do 

func (j *Job) Do(ctx context.Context) <-chan error

Do run job.

func (*Job) HandleErr 

func (j *Job) HandleErr(err error)

HandleErr handle returned error.

func (*Job) Stop 

func (j *Job) Stop(ctx context.Context) error

Stop job.

func (*Job) String 

func (j *Job) String() string

String gets job name.

func (Job) With 

func (j Job) With(opts ...Option) Job

With configure job.

type Manager 

type Manager struct {
	sync.WaitGroup
	// contains filtered or unexported fields
}

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;

func New 

func New(opts ...Option) *Manager

New creates new manager and configure them.

func (*Manager) Close 

func (m *Manager) Close() error

Close jobs.

func (*Manager) Do 

func (m *Manager) Do(ctx context.Context, j *Job, opts ...Option)

Do runs job.

type Option 

type Option func(*Job)

Option configure job.

func Retry 

func Retry(max uint8, handleRetry func(err error) error) Option

Retry set retry job and change return after max retry.

func RunOnce 

func RunOnce() Option

RunOnce run once and stopped job.

func WithDelay 

func WithDelay(delay time.Duration) Option

WithDelay sets delay Run job.

func WithFreq 

func WithFreq(freq time.Duration) Option

WithFreq sets frequency Run job..

func WithHandleErr 

func WithHandleErr(fn func(error)) Option

WithHandleErr add error hanler.

func WithName 

func WithName(name string) Option

WithName sets job name.

func WithRunMiddleware 

func WithRunMiddleware(fn ...Handle) Option

WithRunMiddleware added middleware for the run job.

func WithSchedule 

func WithSchedule(next func(time.Time) time.Duration) Option

WithSchedule set delay and frequency Run job.

func WithStop 

func WithStop(stop Run) Option

WithStop sets stop handle for job.

func WithStopMiddleware 

func WithStopMiddleware(fn ...Handle) Option

WithStopMiddleware added middleware for the stop job.

func WithTimer 

func WithTimer(timer Timer) Option

WithTimer sets time,r to job.

type Run 

type Run func(ctx context.Context) error

Run init function for the change state.

type Timer 

type Timer interface {
	Tick() <-chan time.Time
	Reset(d time.Duration)
	Stop()
}

Timer for the Run job.

func NewTicker 

func NewTicker(freq time.Duration) Timer

NewTicker create new ticker based on time.ticker.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.