schedule

Documentation

Overview

Package schedule is to help you manage schedule tasks.

Example

package main

import (
	"github.com/boxgo/box"
	"github.com/boxgo/box/pkg/logger"
	"github.com/boxgo/box/pkg/schedule"
)

func main() {
	onceHandler := func(args map[string]interface{}) error {
		logger.Info("once handler executing...", args)
		return nil
	}

	timingHandler := func(args map[string]interface{}) error {
		logger.Info("timing handler executing...", args)
		return nil
	}

	sch := schedule.StdConfig("default").Build(schedule.WithHandler(onceHandler, timingHandler))

	app := box.New(
		box.WithBoxes(sch),
	)

	if err := app.Run(); err != nil {
		logger.Fatal(err)
	}
}

Index

• Constants
• type ArgsKey
• type Config
  • func DefaultConfig(key string) *Config
  • func StdConfig(key string) *Config
  • func (c *Config) Build(optionFunc ...OptionFunc) *Schedule
  • func (c *Config) Path() string
• type Handler
• type Journal
• type OptionFunc
  • func WithHandler(onceHandler, timingHandler Handler) OptionFunc
  • func WithLocker(locker locker.MutexLocker) OptionFunc
  • func WithRecorder(recorder Recorder) OptionFunc
  • func WithServer(server *ginserver.GinServer) OptionFunc
• type Recorder
• type Schedule
  • func (sch *Schedule) ExecOnce()
  • func (sch *Schedule) ExecTiming()
  • func (sch *Schedule) Name() string
  • func (sch *Schedule) Serve(context.Context) error
  • func (sch *Schedule) Shutdown(context.Context) error
• type Type

Examples

• Package

Constants

const (
	Stop          = Type(0)
	Once          = Type(1)
	Timing        = Type(2)
	OnceAndTiming = Type(3)
)

Types

type ArgsKey

type ArgsKey struct{}

type Config

type Config struct {
	Type        Type                   `config:"type" desc:"Stop: 0, Once: 1, Timing: 2, OnceAndTiming: 3"`
	Spec        string                 `config:"spec" desc:"Cron spec info"`
	Specs       []string               `config:"specs" desc:"Multi cron spec info, higher priority than spec"`
	Compete     bool                   `config:"compete" desc:"Only winner can exec schedule"`
	AutoUnlock  bool                   `config:"autoUnlock" desc:"Auto unlock after task finish"`
	LockSeconds int                    `config:"lockSeconds" desc:"Lock ttl"`
	Delay       time.Duration          `config:"delay" desc:"Delay duration"`
	Timeout     time.Duration          `config:"timeout" desc:"Execute timeout, default 6h"`
	Args        map[string]interface{} `config:"args" desc:"Schedule arguments"`
	// contains filtered or unexported fields
}

func DefaultConfig

func DefaultConfig(key string) *Config

func StdConfig

func StdConfig(key string) *Config

func (*Config) Build

func (c *Config) Build(optionFunc ...OptionFunc) *Schedule

func (*Config) Path

func (c *Config) Path() string

type Handler

type Handler func(ctx context.Context) error

type Journal

type Journal struct {
	Config    Config
	StartTime time.Time
	EndTime   time.Time
	Error     error
	Panic     interface{}
}

type OptionFunc

type OptionFunc func(*Config)

func WithHandler

func WithHandler(onceHandler, timingHandler Handler) OptionFunc

func WithLocker

func WithLocker(locker locker.MutexLocker) OptionFunc

func WithRecorder

func WithRecorder(recorder Recorder) OptionFunc

func WithServer

func WithServer(server *ginserver.GinServer) OptionFunc

type Recorder

type Recorder func(Journal)

type Schedule

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

Schedule instance is a server, you should mount bo box application to manage lifecycle.

func (*Schedule) ExecOnce

func (sch *Schedule) ExecOnce()

ExecOnce exec once handler immediately

func (*Schedule) ExecTiming

func (sch *Schedule) ExecTiming()

ExecTiming exec timing handler immediately

func (*Schedule) Name

func (sch *Schedule) Name() string

func (*Schedule) Serve

func (sch *Schedule) Serve(context.Context) error

Serve schedule

func (*Schedule) Shutdown

func (sch *Schedule) Shutdown(context.Context) error

Shutdown stop cron

type Type

type Type int