schedule

Documentation

Index

• Constants
• type HandlerFunc
• type Job
  • func (j *Job) DailyAt(time ...string) *Job
  • func (j *Job) OnOneServer() *Job
  • func (j *Job) PerHour(hour int) *Job
  • func (j *Job) PerMinuit(minuit int) *Job
  • func (j *Job) PerSeconds(seconds int) *Job
  • func (j *Job) RandomDelay(min, max int) *Job
  • func (j *Job) WithoutOverlapping() *Job
• type RandomDelay
• type RunTime
• type Schedule
  • func New(logger *logger.Manager, redis *redis.Manager, traceID *trace.ID) *Schedule
  • func (s *Schedule) AddJob(name string, handlerFunc HandlerFunc) *Job
  • func (s *Schedule) Start()

Constants

const (
	DailyRunType      = "daily"
	PerSecondsRunType = "seconds"
	PerMinuitRunType  = "minuit"
	PerHourRunType    = "hour"
)

Types

type HandlerFunc

type HandlerFunc interface {
	Exec(ctx context.Context)
	Error() <-chan error
	Done() <-chan struct{}
}

type Job

type Job struct {
	Name                  string          // 任务实例名
	Logger                *logger.Manager // 日志
	Redis                 *redis.Manager  // Redis
	Handler               HandlerFunc     // 执行器
	EnableMultipleServers bool            // 允许多节点执行
	EnableOverlapping     bool            // 允许即使之前的任务实例还在执行，调度内的任务也会执行
	RunTime               *RunTime        // 任务实例运行时参数
}

func (*Job) DailyAt

func (j *Job) DailyAt(time ...string) *Job

DailyAt 每天 time 执行一次任务，可设置多个时间点 例子：DailyAt("07:30:00", "12:00:00", "18:00:00") 与其他执行时间互斥，每个任务有且只有一个执行时间

func (*Job) OnOneServer

func (j *Job) OnOneServer() *Job

OnOneServer 任务只运行在一台服务器上 需要 Redis 服务支持

func (*Job) PerHour

func (j *Job) PerHour(hour int) *Job

PerHour 每 hour 小时执行一次任务 与其他执行时间互斥，每个任务有且只有一个执行时间

func (*Job) PerMinuit

func (j *Job) PerMinuit(minuit int) *Job

PerMinuit 每 minuit 分钟执行一次任务 与其他执行时间互斥，每个任务有且只有一个执行时间

func (*Job) PerSeconds

func (j *Job) PerSeconds(seconds int) *Job

PerSeconds 每 seconds 秒执行一次任务 与其他执行时间互斥，每个任务有且只有一个执行时间

func (*Job) RandomDelay

func (j *Job) RandomDelay(min, max int) *Job

RandomDelay 设置随机延迟执行时间区间，单位秒。 当 min 和 max 值都不为 0 且 max > min 时，任务会在[min,max]秒之后执行

func (*Job) WithoutOverlapping

func (j *Job) WithoutOverlapping() *Job

WithoutOverlapping 避免任务重复

type RandomDelay

type RandomDelay struct {
	Min int
	Max int
}

type RunTime

type RunTime struct {
	Type          string        // 调度时间类型
	Time          interface{}   // 执行时间（时间点、执行间隔时长）
	Locked        bool          // EnableOverlapping 值为 false 时任务执行锁，保证单节点有且只有一个任务在执行
	PerTypeLocked bool          // 间隔固定时长类型任务锁
	Done          chan struct{} // 执行结束
	RandomDelay   *RandomDelay  // 随机延迟执行时间
}

type Schedule

type Schedule struct {
	Logger  *logger.Manager
	Redis   *redis.Manager
	Job     []*Job
	TraceID *trace.ID
}

func New

func New(logger *logger.Manager, redis *redis.Manager, traceID *trace.ID) *Schedule

func (*Schedule) AddJob

func (s *Schedule) AddJob(name string, handlerFunc HandlerFunc) *Job

func (*Schedule) Start

func (s *Schedule) Start()