1
0
mirror of https://github.com/astaxie/beego.git synced 2024-11-30 01:01:29 +00:00
Beego/toolbox/task.go

616 lines
14 KiB
Go
Raw Normal View History

2014-08-18 08:41:43 +00:00
// Copyright 2014 beego Author. All Rights Reserved.
2014-07-03 15:40:21 +00:00
//
2014-08-18 08:41:43 +00:00
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
2014-07-03 15:40:21 +00:00
//
2014-08-18 08:41:43 +00:00
// http://www.apache.org/licenses/LICENSE-2.0
2014-07-03 15:40:21 +00:00
//
2014-08-18 08:41:43 +00:00
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
2013-11-20 13:17:49 +00:00
package toolbox
import (
"log"
"math"
"sort"
"strconv"
"strings"
"time"
)
// bounds provides a range of acceptable values (plus a map of name to value).
type bounds struct {
min, max uint
names map[string]uint
}
// The bounds for each field.
var (
AdminTaskList map[string]Tasker
stop chan bool
changed chan bool
2014-08-22 05:56:36 +00:00
isstart bool
2013-11-20 13:17:49 +00:00
seconds = bounds{0, 59, nil}
minutes = bounds{0, 59, nil}
hours = bounds{0, 23, nil}
days = bounds{1, 31, nil}
months = bounds{1, 12, map[string]uint{
"jan": 1,
"feb": 2,
"mar": 3,
"apr": 4,
"may": 5,
"jun": 6,
"jul": 7,
"aug": 8,
"sep": 9,
"oct": 10,
"nov": 11,
"dec": 12,
}}
weeks = bounds{0, 6, map[string]uint{
"sun": 0,
"mon": 1,
"tue": 2,
"wed": 3,
"thu": 4,
"fri": 5,
"sat": 6,
}}
)
const (
// Set the top bit if a star was included in the expression.
starBit = 1 << 63
)
2015-09-12 15:28:24 +00:00
// Schedule time taks schedule
2013-11-20 13:17:49 +00:00
type Schedule struct {
Second uint64
Minute uint64
Hour uint64
Day uint64
Month uint64
Week uint64
}
2015-09-12 15:28:24 +00:00
// TaskFunc task func type
2013-11-20 13:17:49 +00:00
type TaskFunc func() error
2015-09-12 15:28:24 +00:00
// Tasker task interface
2013-11-20 13:17:49 +00:00
type Tasker interface {
GetSpec() string
2013-11-20 13:17:49 +00:00
GetStatus() string
Run() error
SetNext(time.Time)
GetNext() time.Time
SetPrev(time.Time)
GetPrev() time.Time
}
2014-01-29 11:12:00 +00:00
// task error
2013-11-20 13:17:49 +00:00
type taskerr struct {
t time.Time
errinfo string
}
2015-09-12 15:28:24 +00:00
// Task task struct
2013-11-20 13:17:49 +00:00
type Task struct {
Taskname string
Spec *Schedule
SpecStr string
2013-11-20 13:17:49 +00:00
DoFunc TaskFunc
Prev time.Time
Next time.Time
2014-01-29 11:12:00 +00:00
Errlist []*taskerr // like errtime:errinfo
ErrLimit int // max length for the errlist, 0 stand for no limit
2013-11-20 13:17:49 +00:00
}
2015-09-12 15:28:24 +00:00
// NewTask add new task with name, time and func
2013-11-20 13:17:49 +00:00
func NewTask(tname string, spec string, f TaskFunc) *Task {
task := &Task{
Taskname: tname,
DoFunc: f,
ErrLimit: 100,
SpecStr: spec,
2013-11-20 13:17:49 +00:00
}
task.SetCron(spec)
return task
}
2015-09-12 15:28:24 +00:00
// GetSpec get spec string
func (t *Task) GetSpec() string {
return t.SpecStr
}
2015-09-12 15:28:24 +00:00
// GetStatus get current task status
func (t *Task) GetStatus() string {
2013-11-20 13:17:49 +00:00
var str string
2015-09-12 15:28:24 +00:00
for _, v := range t.Errlist {
str += v.t.String() + ":" + v.errinfo + "<br>"
2013-11-20 13:17:49 +00:00
}
return str
}
2015-09-12 15:28:24 +00:00
// Run run all tasks
func (t *Task) Run() error {
err := t.DoFunc()
2013-11-20 13:17:49 +00:00
if err != nil {
2015-09-12 15:28:24 +00:00
if t.ErrLimit > 0 && t.ErrLimit > len(t.Errlist) {
t.Errlist = append(t.Errlist, &taskerr{t: t.Next, errinfo: err.Error()})
2013-11-20 13:17:49 +00:00
}
}
return err
}
2015-09-12 15:28:24 +00:00
// SetNext set next time for this task
func (t *Task) SetNext(now time.Time) {
t.Next = t.Spec.Next(now)
2013-11-20 13:17:49 +00:00
}
2015-09-12 15:28:24 +00:00
// GetNext get the next call time of this task
func (t *Task) GetNext() time.Time {
return t.Next
2013-11-20 13:17:49 +00:00
}
2014-01-29 11:12:00 +00:00
2015-09-12 15:28:24 +00:00
// SetPrev set prev time of this task
func (t *Task) SetPrev(now time.Time) {
t.Prev = now
2013-11-20 15:53:54 +00:00
}
2015-09-12 15:28:24 +00:00
// GetPrev get prev time of this task
func (t *Task) GetPrev() time.Time {
return t.Prev
2013-11-20 15:53:54 +00:00
}
2013-11-20 13:17:49 +00:00
2014-01-29 11:12:00 +00:00
// six columns mean
// second0-59
// minute0-59
// hour1-23
// day1-31
// month1-12
// week0-60 means Sunday
2015-09-12 15:28:24 +00:00
// SetCron some signals
2014-01-29 11:12:00 +00:00
// * any time
// ,  separate signal
//   duration
// /n : do as n times of time duration
2013-11-20 13:17:49 +00:00
/////////////////////////////////////////////////////////
2014-01-29 11:12:00 +00:00
// 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
2013-11-20 13:17:49 +00:00
func (t *Task) SetCron(spec string) {
t.Spec = t.parse(spec)
}
func (t *Task) parse(spec string) *Schedule {
if len(spec) > 0 && spec[0] == '@' {
return t.parseSpec(spec)
}
// Split on whitespace. We require 5 or 6 fields.
// (second) (minute) (hour) (day of month) (month) (day of week, optional)
fields := strings.Fields(spec)
if len(fields) != 5 && len(fields) != 6 {
log.Panicf("Expected 5 or 6 fields, found %d: %s", len(fields), spec)
}
// If a sixth field is not provided (DayOfWeek), then it is equivalent to star.
if len(fields) == 5 {
fields = append(fields, "*")
}
schedule := &Schedule{
Second: getField(fields[0], seconds),
Minute: getField(fields[1], minutes),
Hour: getField(fields[2], hours),
Day: getField(fields[3], days),
Month: getField(fields[4], months),
Week: getField(fields[5], weeks),
}
return schedule
}
func (t *Task) parseSpec(spec string) *Schedule {
switch spec {
case "@yearly", "@annually":
return &Schedule{
Second: 1 << seconds.min,
Minute: 1 << minutes.min,
Hour: 1 << hours.min,
Day: 1 << days.min,
Month: 1 << months.min,
Week: all(weeks),
}
case "@monthly":
return &Schedule{
Second: 1 << seconds.min,
Minute: 1 << minutes.min,
Hour: 1 << hours.min,
Day: 1 << days.min,
Month: all(months),
Week: all(weeks),
}
case "@weekly":
return &Schedule{
Second: 1 << seconds.min,
Minute: 1 << minutes.min,
Hour: 1 << hours.min,
Day: all(days),
Month: all(months),
Week: 1 << weeks.min,
}
case "@daily", "@midnight":
return &Schedule{
Second: 1 << seconds.min,
Minute: 1 << minutes.min,
Hour: 1 << hours.min,
Day: all(days),
Month: all(months),
Week: all(weeks),
}
case "@hourly":
return &Schedule{
Second: 1 << seconds.min,
Minute: 1 << minutes.min,
Hour: all(hours),
Day: all(days),
Month: all(months),
Week: all(weeks),
}
}
log.Panicf("Unrecognized descriptor: %s", spec)
return nil
}
2015-09-12 15:28:24 +00:00
// Next set schedule to next time
2013-11-20 13:17:49 +00:00
func (s *Schedule) Next(t time.Time) time.Time {
// Start at the earliest possible time (the upcoming second).
t = t.Add(1*time.Second - time.Duration(t.Nanosecond())*time.Nanosecond)
// This flag indicates whether a field has been incremented.
added := false
// If no time is found within five years, return zero.
yearLimit := t.Year() + 5
WRAP:
if t.Year() > yearLimit {
return time.Time{}
}
// Find the first applicable month.
// If it's this month, then do nothing.
for 1<<uint(t.Month())&s.Month == 0 {
// If we have to add a month, reset the other parts to 0.
if !added {
added = true
// Otherwise, set the date at the beginning (since the current time is irrelevant).
t = time.Date(t.Year(), t.Month(), 1, 0, 0, 0, 0, t.Location())
}
t = t.AddDate(0, 1, 0)
// Wrapped around.
if t.Month() == time.January {
goto WRAP
}
}
// Now get a day in that month.
for !dayMatches(s, t) {
if !added {
added = true
t = time.Date(t.Year(), t.Month(), t.Day(), 0, 0, 0, 0, t.Location())
}
t = t.AddDate(0, 0, 1)
if t.Day() == 1 {
goto WRAP
}
}
for 1<<uint(t.Hour())&s.Hour == 0 {
if !added {
added = true
t = time.Date(t.Year(), t.Month(), t.Day(), t.Hour(), 0, 0, 0, t.Location())
}
t = t.Add(1 * time.Hour)
if t.Hour() == 0 {
goto WRAP
}
}
for 1<<uint(t.Minute())&s.Minute == 0 {
if !added {
added = true
t = time.Date(t.Year(), t.Month(), t.Day(), t.Hour(), t.Minute(), 0, 0, t.Location())
}
t = t.Add(1 * time.Minute)
if t.Minute() == 0 {
goto WRAP
}
}
for 1<<uint(t.Second())&s.Second == 0 {
if !added {
added = true
t = time.Date(t.Year(), t.Month(), t.Day(), t.Hour(), t.Minute(), t.Second(), 0, t.Location())
}
t = t.Add(1 * time.Second)
if t.Second() == 0 {
goto WRAP
}
}
return t
}
func dayMatches(s *Schedule, t time.Time) bool {
var (
2015-09-12 15:28:24 +00:00
domMatch = 1<<uint(t.Day())&s.Day > 0
dowMatch = 1<<uint(t.Weekday())&s.Week > 0
2013-11-20 13:17:49 +00:00
)
if s.Day&starBit > 0 || s.Week&starBit > 0 {
return domMatch && dowMatch
}
return domMatch || dowMatch
}
2015-09-12 15:28:24 +00:00
// StartTask start all tasks
2013-11-20 13:17:49 +00:00
func StartTask() {
2016-04-29 02:28:10 +00:00
if isstart {
//If already started no need to start another goroutine.
return
}
2014-08-22 05:56:36 +00:00
isstart = true
2013-11-20 13:17:49 +00:00
go run()
}
func run() {
now := time.Now().Local()
for _, t := range AdminTaskList {
t.SetNext(now)
}
for {
sortList := NewMapSorter(AdminTaskList)
sortList.Sort()
var effective time.Time
if len(AdminTaskList) == 0 || sortList.Vals[0].GetNext().IsZero() {
// If there are no entries yet, just sleep - it still handles new entries
// and stop requests.
effective = now.AddDate(10, 0, 0)
} else {
effective = sortList.Vals[0].GetNext()
}
select {
case now = <-time.After(effective.Sub(now)):
// Run every entry whose next time was this effective time.
for _, e := range sortList.Vals {
if e.GetNext() != effective {
break
}
2016-04-29 02:28:10 +00:00
go e.Run()
2013-11-20 13:17:49 +00:00
e.SetPrev(e.GetNext())
e.SetNext(effective)
}
continue
case <-changed:
now = time.Now().Local()
continue
2013-11-20 13:17:49 +00:00
case <-stop:
return
}
}
}
2015-09-12 15:28:24 +00:00
// StopTask stop all tasks
2013-11-20 13:17:49 +00:00
func StopTask() {
2016-04-29 02:28:10 +00:00
if isstart {
isstart = false
stop <- true
}
2016-04-26 10:11:49 +00:00
2013-11-20 13:17:49 +00:00
}
2015-09-12 15:28:24 +00:00
// AddTask add task with name
2013-11-20 13:17:49 +00:00
func AddTask(taskname string, t Tasker) {
AdminTaskList[taskname] = t
2014-08-22 05:56:36 +00:00
if isstart {
changed <- true
}
}
2015-09-12 15:28:24 +00:00
// DeleteTask delete task with name
func DeleteTask(taskname string) {
delete(AdminTaskList, taskname)
2014-08-22 05:56:36 +00:00
if isstart {
changed <- true
}
2013-11-20 13:17:49 +00:00
}
2015-09-12 15:28:24 +00:00
// MapSorter sort map for tasker
2013-11-20 13:17:49 +00:00
type MapSorter struct {
Keys []string
Vals []Tasker
}
2015-09-12 15:28:24 +00:00
// NewMapSorter create new tasker map
2013-11-20 13:17:49 +00:00
func NewMapSorter(m map[string]Tasker) *MapSorter {
ms := &MapSorter{
Keys: make([]string, 0, len(m)),
Vals: make([]Tasker, 0, len(m)),
}
for k, v := range m {
ms.Keys = append(ms.Keys, k)
ms.Vals = append(ms.Vals, v)
}
return ms
}
2015-09-12 15:28:24 +00:00
// Sort sort tasker map
2013-11-20 13:17:49 +00:00
func (ms *MapSorter) Sort() {
sort.Sort(ms)
}
func (ms *MapSorter) Len() int { return len(ms.Keys) }
func (ms *MapSorter) Less(i, j int) bool {
if ms.Vals[i].GetNext().IsZero() {
return false
}
if ms.Vals[j].GetNext().IsZero() {
return true
}
return ms.Vals[i].GetNext().Before(ms.Vals[j].GetNext())
}
func (ms *MapSorter) Swap(i, j int) {
ms.Vals[i], ms.Vals[j] = ms.Vals[j], ms.Vals[i]
ms.Keys[i], ms.Keys[j] = ms.Keys[j], ms.Keys[i]
}
func getField(field string, r bounds) uint64 {
// list = range {"," range}
var bits uint64
ranges := strings.FieldsFunc(field, func(r rune) bool { return r == ',' })
for _, expr := range ranges {
bits |= getRange(expr, r)
}
return bits
}
// getRange returns the bits indicated by the given expression:
// number | number "-" number [ "/" number ]
func getRange(expr string, r bounds) uint64 {
var (
start, end, step uint
rangeAndStep = strings.Split(expr, "/")
lowAndHigh = strings.Split(rangeAndStep[0], "-")
singleDigit = len(lowAndHigh) == 1
)
2015-09-12 15:28:24 +00:00
var extrastar uint64
2013-11-20 13:17:49 +00:00
if lowAndHigh[0] == "*" || lowAndHigh[0] == "?" {
start = r.min
end = r.max
2015-09-12 15:28:24 +00:00
extrastar = starBit
2013-11-20 13:17:49 +00:00
} else {
start = parseIntOrName(lowAndHigh[0], r.names)
switch len(lowAndHigh) {
case 1:
end = start
case 2:
end = parseIntOrName(lowAndHigh[1], r.names)
default:
log.Panicf("Too many hyphens: %s", expr)
}
}
switch len(rangeAndStep) {
case 1:
step = 1
case 2:
step = mustParseInt(rangeAndStep[1])
// Special handling: "N/step" means "N-max/step".
if singleDigit {
end = r.max
}
default:
log.Panicf("Too many slashes: %s", expr)
}
if start < r.min {
log.Panicf("Beginning of range (%d) below minimum (%d): %s", start, r.min, expr)
}
if end > r.max {
log.Panicf("End of range (%d) above maximum (%d): %s", end, r.max, expr)
}
if start > end {
log.Panicf("Beginning of range (%d) beyond end of range (%d): %s", start, end, expr)
}
2015-09-12 15:28:24 +00:00
return getBits(start, end, step) | extrastar
2013-11-20 13:17:49 +00:00
}
// parseIntOrName returns the (possibly-named) integer contained in expr.
func parseIntOrName(expr string, names map[string]uint) uint {
if names != nil {
if namedInt, ok := names[strings.ToLower(expr)]; ok {
return namedInt
}
}
return mustParseInt(expr)
}
// mustParseInt parses the given expression as an int or panics.
func mustParseInt(expr string) uint {
num, err := strconv.Atoi(expr)
if err != nil {
log.Panicf("Failed to parse int from %s: %s", expr, err)
}
if num < 0 {
log.Panicf("Negative number (%d) not allowed: %s", num, expr)
}
return uint(num)
}
// getBits sets all bits in the range [min, max], modulo the given step size.
func getBits(min, max, step uint) uint64 {
var bits uint64
// If step is 1, use shifts.
if step == 1 {
return ^(math.MaxUint64 << (max + 1)) & (math.MaxUint64 << min)
}
// Else, use a simple loop.
for i := min; i <= max; i += step {
bits |= 1 << i
}
return bits
}
// all returns all bits within the given bounds. (plus the star bit)
func all(r bounds) uint64 {
return getBits(r.min, r.max, 1) | starBit
}
func init() {
AdminTaskList = make(map[string]Tasker)
2013-11-20 15:53:54 +00:00
stop = make(chan bool)
changed = make(chan bool)
2013-11-20 13:17:49 +00:00
}