mirror of
https://github.com/astaxie/beego.git
synced 2025-06-13 05:50:40 +00:00
Move package
This commit is contained in:
Ming Deng
48
pkg/toolbox/healthcheck.go
Normal file
48
pkg/toolbox/healthcheck.go
Normal file
@ -0,0 +1,48 @@
|
||||
// Copyright 2014 beego Author. All Rights Reserved.
|
||||
//
|
||||
// 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
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// 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.
|
||||
|
||||
// Package toolbox healthcheck
|
||||
//
|
||||
// type DatabaseCheck struct {
|
||||
// }
|
||||
//
|
||||
// func (dc *DatabaseCheck) Check() error {
|
||||
// if dc.isConnected() {
|
||||
// return nil
|
||||
// } else {
|
||||
// return errors.New("can't connect database")
|
||||
// }
|
||||
// }
|
||||
//
|
||||
// AddHealthCheck("database",&DatabaseCheck{})
|
||||
//
|
||||
// more docs: http://beego.me/docs/module/toolbox.md
|
||||
package toolbox
|
||||
|
||||
// AdminCheckList holds health checker map
|
||||
var AdminCheckList map[string]HealthChecker
|
||||
|
||||
// HealthChecker health checker interface
|
||||
type HealthChecker interface {
|
||||
Check() error
|
||||
}
|
||||
|
||||
// AddHealthCheck add health checker with name string
|
||||
func AddHealthCheck(name string, hc HealthChecker) {
|
||||
AdminCheckList[name] = hc
|
||||
}
|
||||
|
||||
func init() {
|
||||
AdminCheckList = make(map[string]HealthChecker)
|
||||
}
|
||||
184
pkg/toolbox/profile.go
Normal file
184
pkg/toolbox/profile.go
Normal file
@ -0,0 +1,184 @@
|
||||
// Copyright 2014 beego Author. All Rights Reserved.
|
||||
//
|
||||
// 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
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// 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.
|
||||
|
||||
package toolbox
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"io"
|
||||
"log"
|
||||
"os"
|
||||
"path"
|
||||
"runtime"
|
||||
"runtime/debug"
|
||||
"runtime/pprof"
|
||||
"strconv"
|
||||
"time"
|
||||
)
|
||||
|
||||
var startTime = time.Now()
|
||||
var pid int
|
||||
|
||||
func init() {
|
||||
pid = os.Getpid()
|
||||
}
|
||||
|
||||
// ProcessInput parse input command string
|
||||
func ProcessInput(input string, w io.Writer) {
|
||||
switch input {
|
||||
case "lookup goroutine":
|
||||
p := pprof.Lookup("goroutine")
|
||||
p.WriteTo(w, 2)
|
||||
case "lookup heap":
|
||||
p := pprof.Lookup("heap")
|
||||
p.WriteTo(w, 2)
|
||||
case "lookup threadcreate":
|
||||
p := pprof.Lookup("threadcreate")
|
||||
p.WriteTo(w, 2)
|
||||
case "lookup block":
|
||||
p := pprof.Lookup("block")
|
||||
p.WriteTo(w, 2)
|
||||
case "get cpuprof":
|
||||
GetCPUProfile(w)
|
||||
case "get memprof":
|
||||
MemProf(w)
|
||||
case "gc summary":
|
||||
PrintGCSummary(w)
|
||||
}
|
||||
}
|
||||
|
||||
// MemProf record memory profile in pprof
|
||||
func MemProf(w io.Writer) {
|
||||
filename := "mem-" + strconv.Itoa(pid) + ".memprof"
|
||||
if f, err := os.Create(filename); err != nil {
|
||||
fmt.Fprintf(w, "create file %s error %s\n", filename, err.Error())
|
||||
log.Fatal("record heap profile failed: ", err)
|
||||
} else {
|
||||
runtime.GC()
|
||||
pprof.WriteHeapProfile(f)
|
||||
f.Close()
|
||||
fmt.Fprintf(w, "create heap profile %s \n", filename)
|
||||
_, fl := path.Split(os.Args[0])
|
||||
fmt.Fprintf(w, "Now you can use this to check it: go tool pprof %s %s\n", fl, filename)
|
||||
}
|
||||
}
|
||||
|
||||
// GetCPUProfile start cpu profile monitor
|
||||
func GetCPUProfile(w io.Writer) {
|
||||
sec := 30
|
||||
filename := "cpu-" + strconv.Itoa(pid) + ".pprof"
|
||||
f, err := os.Create(filename)
|
||||
if err != nil {
|
||||
fmt.Fprintf(w, "Could not enable CPU profiling: %s\n", err)
|
||||
log.Fatal("record cpu profile failed: ", err)
|
||||
}
|
||||
pprof.StartCPUProfile(f)
|
||||
time.Sleep(time.Duration(sec) * time.Second)
|
||||
pprof.StopCPUProfile()
|
||||
|
||||
fmt.Fprintf(w, "create cpu profile %s \n", filename)
|
||||
_, fl := path.Split(os.Args[0])
|
||||
fmt.Fprintf(w, "Now you can use this to check it: go tool pprof %s %s\n", fl, filename)
|
||||
}
|
||||
|
||||
// PrintGCSummary print gc information to io.Writer
|
||||
func PrintGCSummary(w io.Writer) {
|
||||
memStats := &runtime.MemStats{}
|
||||
runtime.ReadMemStats(memStats)
|
||||
gcstats := &debug.GCStats{PauseQuantiles: make([]time.Duration, 100)}
|
||||
debug.ReadGCStats(gcstats)
|
||||
|
||||
printGC(memStats, gcstats, w)
|
||||
}
|
||||
|
||||
func printGC(memStats *runtime.MemStats, gcstats *debug.GCStats, w io.Writer) {
|
||||
|
||||
if gcstats.NumGC > 0 {
|
||||
lastPause := gcstats.Pause[0]
|
||||
elapsed := time.Now().Sub(startTime)
|
||||
overhead := float64(gcstats.PauseTotal) / float64(elapsed) * 100
|
||||
allocatedRate := float64(memStats.TotalAlloc) / elapsed.Seconds()
|
||||
|
||||
fmt.Fprintf(w, "NumGC:%d Pause:%s Pause(Avg):%s Overhead:%3.2f%% Alloc:%s Sys:%s Alloc(Rate):%s/s Histogram:%s %s %s \n",
|
||||
gcstats.NumGC,
|
||||
toS(lastPause),
|
||||
toS(avg(gcstats.Pause)),
|
||||
overhead,
|
||||
toH(memStats.Alloc),
|
||||
toH(memStats.Sys),
|
||||
toH(uint64(allocatedRate)),
|
||||
toS(gcstats.PauseQuantiles[94]),
|
||||
toS(gcstats.PauseQuantiles[98]),
|
||||
toS(gcstats.PauseQuantiles[99]))
|
||||
} else {
|
||||
// while GC has disabled
|
||||
elapsed := time.Now().Sub(startTime)
|
||||
allocatedRate := float64(memStats.TotalAlloc) / elapsed.Seconds()
|
||||
|
||||
fmt.Fprintf(w, "Alloc:%s Sys:%s Alloc(Rate):%s/s\n",
|
||||
toH(memStats.Alloc),
|
||||
toH(memStats.Sys),
|
||||
toH(uint64(allocatedRate)))
|
||||
}
|
||||
}
|
||||
|
||||
func avg(items []time.Duration) time.Duration {
|
||||
var sum time.Duration
|
||||
for _, item := range items {
|
||||
sum += item
|
||||
}
|
||||
return time.Duration(int64(sum) / int64(len(items)))
|
||||
}
|
||||
|
||||
// format bytes number friendly
|
||||
func toH(bytes uint64) string {
|
||||
switch {
|
||||
case bytes < 1024:
|
||||
return fmt.Sprintf("%dB", bytes)
|
||||
case bytes < 1024*1024:
|
||||
return fmt.Sprintf("%.2fK", float64(bytes)/1024)
|
||||
case bytes < 1024*1024*1024:
|
||||
return fmt.Sprintf("%.2fM", float64(bytes)/1024/1024)
|
||||
default:
|
||||
return fmt.Sprintf("%.2fG", float64(bytes)/1024/1024/1024)
|
||||
}
|
||||
}
|
||||
|
||||
// short string format
|
||||
func toS(d time.Duration) string {
|
||||
|
||||
u := uint64(d)
|
||||
if u < uint64(time.Second) {
|
||||
switch {
|
||||
case u == 0:
|
||||
return "0"
|
||||
case u < uint64(time.Microsecond):
|
||||
return fmt.Sprintf("%.2fns", float64(u))
|
||||
case u < uint64(time.Millisecond):
|
||||
return fmt.Sprintf("%.2fus", float64(u)/1000)
|
||||
default:
|
||||
return fmt.Sprintf("%.2fms", float64(u)/1000/1000)
|
||||
}
|
||||
} else {
|
||||
switch {
|
||||
case u < uint64(time.Minute):
|
||||
return fmt.Sprintf("%.2fs", float64(u)/1000/1000/1000)
|
||||
case u < uint64(time.Hour):
|
||||
return fmt.Sprintf("%.2fm", float64(u)/1000/1000/1000/60)
|
||||
default:
|
||||
return fmt.Sprintf("%.2fh", float64(u)/1000/1000/1000/60/60)
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
28
pkg/toolbox/profile_test.go
Normal file
28
pkg/toolbox/profile_test.go
Normal file
@ -0,0 +1,28 @@
|
||||
// Copyright 2014 beego Author. All Rights Reserved.
|
||||
//
|
||||
// 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
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// 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.
|
||||
|
||||
package toolbox
|
||||
|
||||
import (
|
||||
"os"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestProcessInput(t *testing.T) {
|
||||
ProcessInput("lookup goroutine", os.Stdout)
|
||||
ProcessInput("lookup heap", os.Stdout)
|
||||
ProcessInput("lookup threadcreate", os.Stdout)
|
||||
ProcessInput("lookup block", os.Stdout)
|
||||
ProcessInput("gc summary", os.Stdout)
|
||||
}
|
||||
149
pkg/toolbox/statistics.go
Normal file
149
pkg/toolbox/statistics.go
Normal file
@ -0,0 +1,149 @@
|
||||
// Copyright 2014 beego Author. All Rights Reserved.
|
||||
//
|
||||
// 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
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// 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.
|
||||
|
||||
package toolbox
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"sync"
|
||||
"time"
|
||||
)
|
||||
|
||||
// Statistics struct
|
||||
type Statistics struct {
|
||||
RequestURL string
|
||||
RequestController string
|
||||
RequestNum int64
|
||||
MinTime time.Duration
|
||||
MaxTime time.Duration
|
||||
TotalTime time.Duration
|
||||
}
|
||||
|
||||
// URLMap contains several statistics struct to log different data
|
||||
type URLMap struct {
|
||||
lock sync.RWMutex
|
||||
LengthLimit int //limit the urlmap's length if it's equal to 0 there's no limit
|
||||
urlmap map[string]map[string]*Statistics
|
||||
}
|
||||
|
||||
// AddStatistics add statistics task.
|
||||
// it needs request method, request url, request controller and statistics time duration
|
||||
func (m *URLMap) AddStatistics(requestMethod, requestURL, requestController string, requesttime time.Duration) {
|
||||
m.lock.Lock()
|
||||
defer m.lock.Unlock()
|
||||
if method, ok := m.urlmap[requestURL]; ok {
|
||||
if s, ok := method[requestMethod]; ok {
|
||||
s.RequestNum++
|
||||
if s.MaxTime < requesttime {
|
||||
s.MaxTime = requesttime
|
||||
}
|
||||
if s.MinTime > requesttime {
|
||||
s.MinTime = requesttime
|
||||
}
|
||||
s.TotalTime += requesttime
|
||||
} else {
|
||||
nb := &Statistics{
|
||||
RequestURL: requestURL,
|
||||
RequestController: requestController,
|
||||
RequestNum: 1,
|
||||
MinTime: requesttime,
|
||||
MaxTime: requesttime,
|
||||
TotalTime: requesttime,
|
||||
}
|
||||
m.urlmap[requestURL][requestMethod] = nb
|
||||
}
|
||||
|
||||
} else {
|
||||
if m.LengthLimit > 0 && m.LengthLimit <= len(m.urlmap) {
|
||||
return
|
||||
}
|
||||
methodmap := make(map[string]*Statistics)
|
||||
nb := &Statistics{
|
||||
RequestURL: requestURL,
|
||||
RequestController: requestController,
|
||||
RequestNum: 1,
|
||||
MinTime: requesttime,
|
||||
MaxTime: requesttime,
|
||||
TotalTime: requesttime,
|
||||
}
|
||||
methodmap[requestMethod] = nb
|
||||
m.urlmap[requestURL] = methodmap
|
||||
}
|
||||
}
|
||||
|
||||
// GetMap put url statistics result in io.Writer
|
||||
func (m *URLMap) GetMap() map[string]interface{} {
|
||||
m.lock.RLock()
|
||||
defer m.lock.RUnlock()
|
||||
|
||||
var fields = []string{"requestUrl", "method", "times", "used", "max used", "min used", "avg used"}
|
||||
|
||||
var resultLists [][]string
|
||||
content := make(map[string]interface{})
|
||||
content["Fields"] = fields
|
||||
|
||||
for k, v := range m.urlmap {
|
||||
for kk, vv := range v {
|
||||
result := []string{
|
||||
fmt.Sprintf("% -50s", k),
|
||||
fmt.Sprintf("% -10s", kk),
|
||||
fmt.Sprintf("% -16d", vv.RequestNum),
|
||||
fmt.Sprintf("%d", vv.TotalTime),
|
||||
fmt.Sprintf("% -16s", toS(vv.TotalTime)),
|
||||
fmt.Sprintf("%d", vv.MaxTime),
|
||||
fmt.Sprintf("% -16s", toS(vv.MaxTime)),
|
||||
fmt.Sprintf("%d", vv.MinTime),
|
||||
fmt.Sprintf("% -16s", toS(vv.MinTime)),
|
||||
fmt.Sprintf("%d", time.Duration(int64(vv.TotalTime)/vv.RequestNum)),
|
||||
fmt.Sprintf("% -16s", toS(time.Duration(int64(vv.TotalTime)/vv.RequestNum))),
|
||||
}
|
||||
resultLists = append(resultLists, result)
|
||||
}
|
||||
}
|
||||
content["Data"] = resultLists
|
||||
return content
|
||||
}
|
||||
|
||||
// GetMapData return all mapdata
|
||||
func (m *URLMap) GetMapData() []map[string]interface{} {
|
||||
m.lock.RLock()
|
||||
defer m.lock.RUnlock()
|
||||
|
||||
var resultLists []map[string]interface{}
|
||||
|
||||
for k, v := range m.urlmap {
|
||||
for kk, vv := range v {
|
||||
result := map[string]interface{}{
|
||||
"request_url": k,
|
||||
"method": kk,
|
||||
"times": vv.RequestNum,
|
||||
"total_time": toS(vv.TotalTime),
|
||||
"max_time": toS(vv.MaxTime),
|
||||
"min_time": toS(vv.MinTime),
|
||||
"avg_time": toS(time.Duration(int64(vv.TotalTime) / vv.RequestNum)),
|
||||
}
|
||||
resultLists = append(resultLists, result)
|
||||
}
|
||||
}
|
||||
return resultLists
|
||||
}
|
||||
|
||||
// StatisticsMap hosld global statistics data map
|
||||
var StatisticsMap *URLMap
|
||||
|
||||
func init() {
|
||||
StatisticsMap = &URLMap{
|
||||
urlmap: make(map[string]map[string]*Statistics),
|
||||
}
|
||||
}
|
||||
40
pkg/toolbox/statistics_test.go
Normal file
40
pkg/toolbox/statistics_test.go
Normal file
@ -0,0 +1,40 @@
|
||||
// Copyright 2014 beego Author. All Rights Reserved.
|
||||
//
|
||||
// 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
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// 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.
|
||||
|
||||
package toolbox
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"testing"
|
||||
"time"
|
||||
)
|
||||
|
||||
func TestStatics(t *testing.T) {
|
||||
StatisticsMap.AddStatistics("POST", "/api/user", "&admin.user", time.Duration(2000))
|
||||
StatisticsMap.AddStatistics("POST", "/api/user", "&admin.user", time.Duration(120000))
|
||||
StatisticsMap.AddStatistics("GET", "/api/user", "&admin.user", time.Duration(13000))
|
||||
StatisticsMap.AddStatistics("POST", "/api/admin", "&admin.user", time.Duration(14000))
|
||||
StatisticsMap.AddStatistics("POST", "/api/user/astaxie", "&admin.user", time.Duration(12000))
|
||||
StatisticsMap.AddStatistics("POST", "/api/user/xiemengjun", "&admin.user", time.Duration(13000))
|
||||
StatisticsMap.AddStatistics("DELETE", "/api/user", "&admin.user", time.Duration(1400))
|
||||
t.Log(StatisticsMap.GetMap())
|
||||
|
||||
data := StatisticsMap.GetMapData()
|
||||
b, err := json.Marshal(data)
|
||||
if err != nil {
|
||||
t.Errorf(err.Error())
|
||||
}
|
||||
|
||||
t.Log(string(b))
|
||||
}
|
||||
640
pkg/toolbox/task.go
Normal file
640
pkg/toolbox/task.go
Normal file
@ -0,0 +1,640 @@
|
||||
// Copyright 2014 beego Author. All Rights Reserved.
|
||||
//
|
||||
// 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
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// 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.
|
||||
|
||||
package toolbox
|
||||
|
||||
import (
|
||||
"log"
|
||||
"math"
|
||||
"sort"
|
||||
"strconv"
|
||||
"strings"
|
||||
"sync"
|
||||
"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
|
||||
taskLock sync.RWMutex
|
||||
stop chan bool
|
||||
changed chan bool
|
||||
isstart bool
|
||||
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
|
||||
)
|
||||
|
||||
// Schedule time taks schedule
|
||||
type Schedule struct {
|
||||
Second uint64
|
||||
Minute uint64
|
||||
Hour uint64
|
||||
Day uint64
|
||||
Month uint64
|
||||
Week uint64
|
||||
}
|
||||
|
||||
// TaskFunc task func type
|
||||
type TaskFunc func() error
|
||||
|
||||
// Tasker task interface
|
||||
type Tasker interface {
|
||||
GetSpec() string
|
||||
GetStatus() string
|
||||
Run() error
|
||||
SetNext(time.Time)
|
||||
GetNext() time.Time
|
||||
SetPrev(time.Time)
|
||||
GetPrev() time.Time
|
||||
}
|
||||
|
||||
// task error
|
||||
type taskerr struct {
|
||||
t time.Time
|
||||
errinfo string
|
||||
}
|
||||
|
||||
// Task task struct
|
||||
// It's not a thread-safe structure.
|
||||
// Only nearest errors will be saved in ErrList
|
||||
type Task struct {
|
||||
Taskname string
|
||||
Spec *Schedule
|
||||
SpecStr string
|
||||
DoFunc TaskFunc
|
||||
Prev time.Time
|
||||
Next time.Time
|
||||
Errlist []*taskerr // like errtime:errinfo
|
||||
ErrLimit int // max length for the errlist, 0 stand for no limit
|
||||
errCnt int // records the error count during the execution
|
||||
}
|
||||
|
||||
// NewTask add new task with name, time and func
|
||||
func NewTask(tname string, spec string, f TaskFunc) *Task {
|
||||
|
||||
task := &Task{
|
||||
Taskname: tname,
|
||||
DoFunc: f,
|
||||
// Make configurable
|
||||
ErrLimit: 100,
|
||||
SpecStr: spec,
|
||||
// we only store the pointer, so it won't use too many space
|
||||
Errlist: make([]*taskerr, 100, 100),
|
||||
}
|
||||
task.SetCron(spec)
|
||||
return task
|
||||
}
|
||||
|
||||
// GetSpec get spec string
|
||||
func (t *Task) GetSpec() string {
|
||||
return t.SpecStr
|
||||
}
|
||||
|
||||
// GetStatus get current task status
|
||||
func (t *Task) GetStatus() string {
|
||||
var str string
|
||||
for _, v := range t.Errlist {
|
||||
str += v.t.String() + ":" + v.errinfo + "<br>"
|
||||
}
|
||||
return str
|
||||
}
|
||||
|
||||
// Run run all tasks
|
||||
func (t *Task) Run() error {
|
||||
err := t.DoFunc()
|
||||
if err != nil {
|
||||
index := t.errCnt % t.ErrLimit
|
||||
t.Errlist[index] = &taskerr{t: t.Next, errinfo: err.Error()}
|
||||
t.errCnt++
|
||||
}
|
||||
return err
|
||||
}
|
||||
|
||||
// SetNext set next time for this task
|
||||
func (t *Task) SetNext(now time.Time) {
|
||||
t.Next = t.Spec.Next(now)
|
||||
}
|
||||
|
||||
// GetNext get the next call time of this task
|
||||
func (t *Task) GetNext() time.Time {
|
||||
return t.Next
|
||||
}
|
||||
|
||||
// SetPrev set prev time of this task
|
||||
func (t *Task) SetPrev(now time.Time) {
|
||||
t.Prev = now
|
||||
}
|
||||
|
||||
// GetPrev get prev time of this task
|
||||
func (t *Task) GetPrev() time.Time {
|
||||
return t.Prev
|
||||
}
|
||||
|
||||
// six columns mean：
|
||||
// second：0-59
|
||||
// minute：0-59
|
||||
// hour：1-23
|
||||
// day：1-31
|
||||
// month：1-12
|
||||
// week：0-6（0 means Sunday）
|
||||
|
||||
// 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 (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
|
||||
}
|
||||
|
||||
// Next set schedule to next time
|
||||
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 (
|
||||
domMatch = 1<<uint(t.Day())&s.Day > 0
|
||||
dowMatch = 1<<uint(t.Weekday())&s.Week > 0
|
||||
)
|
||||
|
||||
if s.Day&starBit > 0 || s.Week&starBit > 0 {
|
||||
return domMatch && dowMatch
|
||||
}
|
||||
return domMatch || dowMatch
|
||||
}
|
||||
|
||||
// StartTask start all tasks
|
||||
func StartTask() {
|
||||
taskLock.Lock()
|
||||
defer taskLock.Unlock()
|
||||
if isstart {
|
||||
//If already started， no need to start another goroutine.
|
||||
return
|
||||
}
|
||||
isstart = true
|
||||
go run()
|
||||
}
|
||||
|
||||
func run() {
|
||||
now := time.Now().Local()
|
||||
for _, t := range AdminTaskList {
|
||||
t.SetNext(now)
|
||||
}
|
||||
|
||||
for {
|
||||
// we only use RLock here because NewMapSorter copy the reference, do not change any thing
|
||||
taskLock.RLock()
|
||||
sortList := NewMapSorter(AdminTaskList)
|
||||
taskLock.RUnlock()
|
||||
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
|
||||
}
|
||||
go e.Run()
|
||||
e.SetPrev(e.GetNext())
|
||||
e.SetNext(effective)
|
||||
}
|
||||
continue
|
||||
case <-changed:
|
||||
now = time.Now().Local()
|
||||
taskLock.Lock()
|
||||
for _, t := range AdminTaskList {
|
||||
t.SetNext(now)
|
||||
}
|
||||
taskLock.Unlock()
|
||||
continue
|
||||
case <-stop:
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// StopTask stop all tasks
|
||||
func StopTask() {
|
||||
taskLock.Lock()
|
||||
defer taskLock.Unlock()
|
||||
if isstart {
|
||||
isstart = false
|
||||
stop <- true
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// AddTask add task with name
|
||||
func AddTask(taskname string, t Tasker) {
|
||||
taskLock.Lock()
|
||||
defer taskLock.Unlock()
|
||||
t.SetNext(time.Now().Local())
|
||||
AdminTaskList[taskname] = t
|
||||
if isstart {
|
||||
changed <- true
|
||||
}
|
||||
}
|
||||
|
||||
// DeleteTask delete task with name
|
||||
func DeleteTask(taskname string) {
|
||||
taskLock.Lock()
|
||||
defer taskLock.Unlock()
|
||||
delete(AdminTaskList, taskname)
|
||||
if isstart {
|
||||
changed <- true
|
||||
}
|
||||
}
|
||||
|
||||
// MapSorter sort map for tasker
|
||||
type MapSorter struct {
|
||||
Keys []string
|
||||
Vals []Tasker
|
||||
}
|
||||
|
||||
// NewMapSorter create new tasker map
|
||||
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
|
||||
}
|
||||
|
||||
// Sort sort tasker map
|
||||
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
|
||||
)
|
||||
|
||||
var extrastar uint64
|
||||
if lowAndHigh[0] == "*" || lowAndHigh[0] == "?" {
|
||||
start = r.min
|
||||
end = r.max
|
||||
extrastar = starBit
|
||||
} 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)
|
||||
}
|
||||
|
||||
return getBits(start, end, step) | extrastar
|
||||
}
|
||||
|
||||
// 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)
|
||||
stop = make(chan bool)
|
||||
changed = make(chan bool)
|
||||
}
|
||||
85
pkg/toolbox/task_test.go
Normal file
85
pkg/toolbox/task_test.go
Normal file
@ -0,0 +1,85 @@
|
||||
// Copyright 2014 beego Author. All Rights Reserved.
|
||||
//
|
||||
// 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
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// 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.
|
||||
|
||||
package toolbox
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"fmt"
|
||||
"sync"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"github.com/stretchr/testify/assert"
|
||||
)
|
||||
|
||||
func TestParse(t *testing.T) {
|
||||
tk := NewTask("taska", "0/30 * * * * *", func() error { fmt.Println("hello world"); return nil })
|
||||
err := tk.Run()
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
AddTask("taska", tk)
|
||||
StartTask()
|
||||
time.Sleep(6 * time.Second)
|
||||
StopTask()
|
||||
}
|
||||
|
||||
func TestSpec(t *testing.T) {
|
||||
wg := &sync.WaitGroup{}
|
||||
wg.Add(2)
|
||||
tk1 := NewTask("tk1", "0 12 * * * *", func() error { fmt.Println("tk1"); return nil })
|
||||
tk2 := NewTask("tk2", "0,10,20 * * * * *", func() error { fmt.Println("tk2"); wg.Done(); return nil })
|
||||
tk3 := NewTask("tk3", "0 10 * * * *", func() error { fmt.Println("tk3"); wg.Done(); return nil })
|
||||
|
||||
AddTask("tk1", tk1)
|
||||
AddTask("tk2", tk2)
|
||||
AddTask("tk3", tk3)
|
||||
StartTask()
|
||||
defer StopTask()
|
||||
|
||||
select {
|
||||
case <-time.After(200 * time.Second):
|
||||
t.FailNow()
|
||||
case <-wait(wg):
|
||||
}
|
||||
}
|
||||
|
||||
func TestTask_Run(t *testing.T) {
|
||||
cnt := -1
|
||||
task := func() error {
|
||||
cnt ++
|
||||
fmt.Printf("Hello, world! %d \n", cnt)
|
||||
return errors.New(fmt.Sprintf("Hello, world! %d", cnt))
|
||||
}
|
||||
tk := NewTask("taska", "0/30 * * * * *", task)
|
||||
for i := 0; i < 200 ; i ++ {
|
||||
e := tk.Run()
|
||||
assert.NotNil(t, e)
|
||||
}
|
||||
|
||||
l := tk.Errlist
|
||||
assert.Equal(t, 100, len(l))
|
||||
assert.Equal(t, "Hello, world! 100", l[0].errinfo)
|
||||
assert.Equal(t, "Hello, world! 101", l[1].errinfo)
|
||||
}
|
||||
|
||||
func wait(wg *sync.WaitGroup) chan bool {
|
||||
ch := make(chan bool)
|
||||
go func() {
|
||||
wg.Wait()
|
||||
ch <- true
|
||||
}()
|
||||
return ch
|
||||
}
|
||||
Reference in New Issue
Block a user