delayquene

package
v1.6.22 Latest Latest
Warning

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

 Go to latest Published: Mar 14, 2023 License: MIT Imports: 27 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var UrlRe = regexp.MustCompile(`^(HTTP|REMOTE|LUA)\@(.+)?`)

Functions

func RedisScan added in v1.4.1 

func RedisScan(c redis.Conn, match string) (keys []string, err error)

取代 keys 效能更好

Types

type Bucket 

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

func (*Bucket) Close added in v1.4.17 

func (b *Bucket) Close()

func (*Bucket) Get 

func (b *Bucket) Get(key string) (items []*BucketItem, err error)

func (*Bucket) JobCheck added in v1.4.0 

func (b *Bucket) JobCheck(key string, now time.Time, machineHost string) (err error)

func (*Bucket) Push 

func (b *Bucket) Push(key string, timestamp int64, jobId string) (err error)

func (*Bucket) Remove 

func (b *Bucket) Remove(key string, jobId string) (err error)

func (*Bucket) RemoveAndPush added in v1.6.0 

func (b *Bucket) RemoveAndPush(removeKey string, puahKey string, jobId string, timestamp int64) (err error)

type BucketItem 

type BucketItem struct {
	Timestamp int64
	JobId     string
}

type Config 

type Config struct {
	RedisForDelayQueneDBNo    int
	RedisForDelayQueneMaxIdle int
	RedisForDelayQueneMaxConn int
	MachineHost               string
	MachineMac                string
	MachineIp                 string
	JobReplyUrl               string
	Logger                    *logrus.Logger
}

type ConstantDelaySchedule 

type ConstantDelaySchedule struct {
	Delay time.Duration
}

func Every 

func Every(duration time.Duration) ConstantDelaySchedule

Every returns a crontab Schedule that activates once every duration. Delays of less than a second are not supported (will round up to 1 second). Any fields less than a Second are truncated.

func (ConstantDelaySchedule) Next 

func (schedule ConstantDelaySchedule) Next(t time.Time) time.Time

Next returns the next time this should be run. This rounds so that the next activation time will be on the second.

type JobQuene 

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

func (*JobQuene) Add 

func (j *JobQuene) Add(key string, jb *guaproto.Job) (err error)

func (*JobQuene) Exist added in v1.5.0 

func (j *JobQuene) Exist(key string) (duplicate int, err error)

func (*JobQuene) Get 

func (j *JobQuene) Get(key string) (jb *guaproto.Job, err error)

func (*JobQuene) List 

func (j *JobQuene) List(key string) (jobs []*guaproto.Job, err error)

func (*JobQuene) Remove 

func (j *JobQuene) Remove(key string) (err error)

func (*JobQuene) Update added in v1.5.4 

func (j *JobQuene) Update(key string, jb *guaproto.Job) (err error)

type ParseOption 

type ParseOption int

Configuration options for creating a parser. Most options specify which fields should be included, while others enable features. If a field is not included the parser will assume a default value. These options do not change the order fields are parse in. 

const (
	Second      ParseOption = 1 << iota // Seconds field, default 0
	Minute                              // Minutes field, default 0
	Hour                                // Hours field, default 0
	Dom                                 // Day of month field, default *
	Month                               // Month field, default *
	Dow                                 // Day of week field, default *
	DowOptional                         // Optional day of week field, default *
	Descriptor                          // Allow descriptors such as @monthly, @weekly, etc.
)

type Parser 

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

A custom Parser that can be configured.

func NewParser 

func NewParser(options ParseOption) Parser

Creates a custom Parser with custom options. 

// Standard parser without descriptors
specParser := NewParser(Minute | Hour | Dom | Month | Dow)
sched, err := specParser.Parse("0 0 15 */3 *")

// Same as above, just excludes time fields
subsParser := NewParser(Dom | Month | Dow)
sched, err := specParser.Parse("15 */3 *")

// Same as above, just makes Dow optional
subsParser := NewParser(Dom | Month | DowOptional)
sched, err := specParser.Parse("15 */3")

func (Parser) Parse 

func (p Parser) Parse(spec string) (Schedule, error)

Parse returns a new crontab schedule representing the given spec. It returns a descriptive error if the spec is not valid. It accepts crontab specs and features configured by NewParser.

type Quene 

type Quene interface {
	Heartbeat(nodeId string, groupName string) (err error)
	GenerateUID() (s string)
	Remove(jobId string) (err error)
	Edit(groupName, jobId, requestUrl, execCmd string) (err error)
	Active(groupName string, jobId string, exectime int64) (err error)
	Pause(groupName string, jobId string) (err error)
	Delete(groupName string, jobId string) (err error)
	List(groupName string) (jobs []*guaproto.Job, err error)
	Push(job *guaproto.Job) (err error)
	RegisterNode(nodeInfo *guaproto.NodeRegisterRequest) (resp *guaproto.NodeRegisterResponse, err error)
	RegisterGroup(groupName string) (otpToken string, err error)
	QueryNodes(groupName string) (nodes []*guaproto.NodeRegisterRequest, err error)
	QueryGroups() (s []string, err error)
	GroupInfo(groupName string) (s string, err error)
	Close()
	RemoveGroup(groupName string) (err error)
	ExistsGroup(groupName string) (exists int, err error)
}

func New 

func New(config *Config, groupRedis *redis.Pool, readyRedis *redis.Pool, delayRedis *redis.Pool) (quene Quene, err error)

type Schedule 

type Schedule interface {
	// Return the next activation time, later than the given time.
	// Next is invoked initially, and then each time the job is run.
	Next(time.Time) time.Time
}

func Parse 

func Parse(spec string) (Schedule, error)

Parse returns a new crontab schedule representing the given spec. It returns a descriptive error if the spec is not valid.

It accepts

  • Full crontab specs, e.g. "* * * * * ?"
  • Descriptors, e.g. "@midnight", "@every 1h30m"

func ParseStandard 

func ParseStandard(standardSpec string) (Schedule, error)

ParseStandard returns a new crontab schedule representing the given standardSpec (https://en.wikipedia.org/wiki/Cron). It differs from Parse requiring to always pass 5 entries representing: minute, hour, day of month, month and day of week, in that order. It returns a descriptive error if the spec is not valid.

It accepts

  • Standard crontab specs, e.g. "* * * * ?"
  • Descriptors, e.g. "@midnight", "@every 1h30m"

type SpecSchedule 

type SpecSchedule struct {
	Second, Minute, Hour, Dom, Month, Dow uint64
}

SpecSchedule specifies a duty cycle (to the second granularity), based on a traditional crontab specification. It is computed initially and stored as bit sets.

func (*SpecSchedule) Next 

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

Next returns the next time this schedule is activated, greater than the given time. If no time can be found to satisfy the schedule, return the zero time.

type Worker 

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

func (*Worker) Close 

func (t *Worker) Close()

func (*Worker) DelayQueneHandler 

func (t *Worker) DelayQueneHandler(ti time.Time, realBucketName string) (err error)

func (*Worker) DelayQueneWorker 

func (t *Worker) DelayQueneWorker(timer *time.Ticker, closeSign chan int, realBucketName string)

func (*Worker) ExecuteJob 

func (t *Worker) ExecuteJob(job *guaproto.ReadyJob) (err error)

func (*Worker) GenerateBucketName 

func (t *Worker) GenerateBucketName() <-chan string

func (*Worker) ReadyQueneWorker 

func (t *Worker) ReadyQueneWorker()

func (*Worker) RunForDelayQuene 

func (t *Worker) RunForDelayQuene()

func (*Worker) RunForReadQuene 

func (t *Worker) RunForReadQuene()

func (*Worker) RunJobCheck added in v1.4.0 

func (t *Worker) RunJobCheck()

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.