crontab

Documentation

Index

• type MapSorter
  • func NewMapSorter(m map[string]Tasker) *MapSorter
  • func (ms *MapSorter) Len() int
  • func (ms *MapSorter) Less(i, j int) bool
  • func (ms *MapSorter) Sort()
  • func (ms *MapSorter) Swap(i, j int)
• type Option
  • func TimeoutOption(timeout time.Duration) Option
• type Schedule
  • func (s *Schedule) Next(t time.Time) time.Time
• type Task
  • func NewTask(tname string, spec string, f TaskFunc, opts ...Option) *Task
  • func (t *Task) GetNext(context.Context) time.Time
  • func (t *Task) GetPrev(context.Context) time.Time
  • func (t *Task) GetSpec(context.Context) string
  • func (t *Task) GetStatus(context.Context) string
  • func (t *Task) GetTimeout(context.Context) time.Duration
  • func (t *Task) Run(ctx context.Context) error
  • func (t *Task) SetCron(spec string)
  • func (t *Task) SetNext(ctx context.Context, now time.Time)
  • func (t *Task) SetPrev(ctx context.Context, now time.Time)
• type TaskFunc
• type TaskManager
  • func NewTaskManager() *TaskManager
  • func (t *TaskManager) AddTask(taskname string, task Tasker)
  • func (t *TaskManager) ClearTask()
  • func (t *TaskManager) DeleteTask(taskname string)
  • func (t *TaskManager) GracefulShutdown() <-chan struct{}
  • func (t *TaskManager) Len() int
  • func (t *TaskManager) StartTask()
  • func (t *TaskManager) StopTask()
  • func (t *TaskManager) WorkerStart() error
  • func (t *TaskManager) WorkerStop() error
• type Tasker

Types

type MapSorter

type MapSorter struct {
	Keys []string
	Vals []Tasker
}

MapSorter sort map for tasker

func NewMapSorter

func NewMapSorter(m map[string]Tasker) *MapSorter

NewMapSorter create new tasker map

func (*MapSorter) Len

func (ms *MapSorter) Len() int

Len ...

func (*MapSorter) Less

func (ms *MapSorter) Less(i, j int) bool

Less ...

func (*MapSorter) Sort

func (ms *MapSorter) Sort()

Sort sort tasker map

func (*MapSorter) Swap

func (ms *MapSorter) Swap(i, j int)

Swap ...

type Option

type Option interface {
	// contains filtered or unexported methods
}

Option interface

func TimeoutOption

func TimeoutOption(timeout time.Duration) Option

TimeoutOption return a option to set timeout duration for task

type Schedule

type Schedule struct {
	Second uint64
	Minute uint64
	Hour   uint64
	Day    uint64
	Month  uint64
	Week   uint64
}

Schedule time taks schedule

func (*Schedule) Next

func (s *Schedule) Next(t time.Time) time.Time

Next set schedule to next time

type Task

type Task struct {
	Taskname string
	Spec     *Schedule
	SpecStr  string
	DoFunc   TaskFunc
	Prev     time.Time
	Next     time.Time
	Timeout  time.Duration // timeout duration
	Errlist  []*taskerr    // like errtime:errinfo
	ErrLimit int           // max length for the errlist, 0 stand for no limit
	// contains filtered or unexported fields
}

Task task struct It's not a thread-safe structure. Only nearest errors will be saved in ErrList

func NewTask

func NewTask(tname string, spec string, f TaskFunc, opts ...Option) *Task

NewTask add new task with name, time and func

func (*Task) GetNext

func (t *Task) GetNext(context.Context) time.Time

GetNext get the next call time of this task

func (*Task) GetPrev

func (t *Task) GetPrev(context.Context) time.Time

GetPrev get prev time of this task

func (*Task) GetSpec

func (t *Task) GetSpec(context.Context) string

GetSpec get spec string

func (*Task) GetStatus

func (t *Task) GetStatus(context.Context) string

GetStatus get current task status

func (*Task) GetTimeout

func (t *Task) GetTimeout(context.Context) time.Duration

GetTimeout get timeout duration of this task

func (*Task) Run

func (t *Task) Run(ctx context.Context) error

Run run all tasks

func (*Task) SetCron

func (t *Task) SetCron(spec string)

SetCron some signals：

*： any time
,：　 separate signal

　　 －：duration

/n : do as n times of time duration

///////////////////////////////////////////////////////

0/30 * * * * *                        every 30s
0 43 21 * * *                         21:43
0 15 05 * * * 　　                     05:15
0 0 17 * * *                          17:00
0 0 17 * * 1                           17:00 in every Monday
0 0,10 17 * * 0,2,3                   17:00 and 17:10 in every Sunday, Tuesday and Wednesday
0 0-10 17 1 * *                       17:00 to 17:10 in 1 min duration each time on the first day of month
0 0 0 1,15 * 1                        0:00 on the 1st day and 15th day of month
0 42 4 1 * * 　 　                     4:42 on the 1st day of month
0 0 21 * * 1-6　　                     21:00 from Monday to Saturday
0 0,10,20,30,40,50 * * * *　           every 10 min duration
0 */10 * * * * 　　　　　　              every 10 min duration
0 * 1 * * *　　　　　　　　               1:00 to 1:59 in 1 min duration each time
0 0 1 * * *　　　　　　　　               1:00
0 0 */1 * * *　　　　　　　               0 min of hour in 1 hour duration
0 0 * * * *　　　　　　　　               0 min of hour in 1 hour duration
0 2 8-20/3 * * *　　　　　　             8:02, 11:02, 14:02, 17:02, 20:02
0 30 5 1,15 * *　　　　　　              5:30 on the 1st day and 15th day of month

func (*Task) SetNext

func (t *Task) SetNext(ctx context.Context, now time.Time)

SetNext set next time for this task

func (*Task) SetPrev

func (t *Task) SetPrev(ctx context.Context, now time.Time)

SetPrev set prev time of this task

type TaskFunc

type TaskFunc func(ctx context.Context) error

TaskFunc task func type

type TaskManager

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

TaskManager ...

func NewTaskManager

func NewTaskManager() *TaskManager

NewTaskManager ...

func (*TaskManager) AddTask

func (t *TaskManager) AddTask(taskname string, task Tasker)

AddTask add task with name

func (*TaskManager) ClearTask

func (t *TaskManager) ClearTask()

ClearTask clear all tasks

func (*TaskManager) DeleteTask

func (t *TaskManager) DeleteTask(taskname string)

DeleteTask delete task with name

func (*TaskManager) GracefulShutdown

func (t *TaskManager) GracefulShutdown() <-chan struct{}

GracefulShutdown wait all task done

func (*TaskManager) Len

func (t *TaskManager) Len() int

Len ...

func (*TaskManager) StartTask

func (t *TaskManager) StartTask()

StartTask start all tasks

func (*TaskManager) StopTask

func (t *TaskManager) StopTask()

StopTask stop all tasks

func (*TaskManager) WorkerStart

func (t *TaskManager) WorkerStart() error

WorkerStart ...

func (*TaskManager) WorkerStop

func (t *TaskManager) WorkerStop() error

WorkerStop ...

type Tasker

type Tasker interface {
	GetSpec(ctx context.Context) string
	GetStatus(ctx context.Context) string
	Run(ctx context.Context) error
	SetNext(context.Context, time.Time)
	GetNext(ctx context.Context) time.Time
	SetPrev(context.Context, time.Time)
	GetPrev(ctx context.Context) time.Time
	GetTimeout(ctx context.Context) time.Duration
}

Tasker task interface