You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
569 lines
12 KiB
Go
569 lines
12 KiB
Go
package startimer
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"sort"
|
|
"sync"
|
|
"time"
|
|
)
|
|
|
|
func NewTimer(baseDate time.Time, opts ...TimerOptions) (StarTimer, error) {
|
|
timer := StarTimer{
|
|
base: baseDate,
|
|
nextDate: time.Time{},
|
|
mu: new(sync.RWMutex),
|
|
}
|
|
for _, opt := range opts {
|
|
var op TimerOption
|
|
opt(&op)
|
|
switch op.idx {
|
|
case 3:
|
|
timer.repeat = append(timer.repeat, &Repeats{
|
|
Repeat: []Repeat{
|
|
{
|
|
Unit: STAR_YEAR,
|
|
Value: uint32(op.date.Year()),
|
|
},
|
|
{
|
|
Unit: STAR_MONTH,
|
|
Value: uint32(op.date.Month()),
|
|
},
|
|
{
|
|
Unit: STAR_DAY,
|
|
Value: uint32(op.date.Day()),
|
|
},
|
|
{
|
|
Unit: STAR_HOUR,
|
|
Value: uint32(op.date.Hour()),
|
|
},
|
|
{
|
|
Unit: STAR_MINUTE,
|
|
Value: uint32(op.date.Minute()),
|
|
},
|
|
{
|
|
Unit: STAR_SECOND,
|
|
Value: uint32(op.date.Second()),
|
|
},
|
|
},
|
|
Every: false,
|
|
})
|
|
case 4:
|
|
timer.repeat = append(timer.repeat, &Repeats{
|
|
Repeat: []Repeat{op.repeat},
|
|
Every: true,
|
|
})
|
|
}
|
|
|
|
if op.repeats != nil {
|
|
if err := timer.repeatsCheck(op.repeats); err != nil {
|
|
return timer, err
|
|
}
|
|
timer.repeat = append(timer.repeat, op.repeats)
|
|
}
|
|
if op.tasks != nil {
|
|
timer.tasks = append(timer.tasks, op.tasks)
|
|
}
|
|
if op.runLimit > 0 {
|
|
timer.runLimit = op.runLimit
|
|
}
|
|
}
|
|
return timer, nil
|
|
}
|
|
|
|
func (t *StarTimer) repeatsCheck(rp *Repeats) error {
|
|
if rp == nil {
|
|
return errors.New("nil point of Repeats")
|
|
}
|
|
if rp.Every {
|
|
return nil
|
|
}
|
|
for _, r := range rp.Repeat {
|
|
switch r.Unit {
|
|
case STAR_MINUTE, STAR_SECOND:
|
|
if r.Value > 60 || r.Value < 0 {
|
|
return fmt.Errorf("invalid value:%d", r.Value)
|
|
}
|
|
case STAR_HOUR:
|
|
if r.Value > 24 || r.Value < 0 {
|
|
return fmt.Errorf("invalid value:%d", r.Value)
|
|
}
|
|
case STAR_MONTH:
|
|
if r.Value > 12 || r.Value < 1 {
|
|
return fmt.Errorf("invalid value:%d", r.Value)
|
|
}
|
|
case STAR_DAY:
|
|
if r.Value > 31 || r.Value < 1 {
|
|
return fmt.Errorf("invalid value:%d", r.Value)
|
|
}
|
|
case STAR_WEEK:
|
|
if r.Value > 7 || r.Value < 0 {
|
|
return fmt.Errorf("invalid value:%d", r.Value)
|
|
}
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (t *StarTimer) IsRunning() bool {
|
|
t.mu.RLock()
|
|
defer t.mu.RUnlock()
|
|
return t.running
|
|
}
|
|
|
|
func (t *StarTimer) SetRunCountLimit(c int) {
|
|
t.runLimit = c
|
|
}
|
|
|
|
func (t *StarTimer) RunCountLimit() int {
|
|
return t.runLimit
|
|
}
|
|
|
|
func (t *StarTimer) AddTask(task func()) {
|
|
t.tasks = append(t.tasks, task)
|
|
}
|
|
|
|
func (t *StarTimer) SetTasks(tasks []func()) {
|
|
t.tasks = tasks
|
|
}
|
|
|
|
func (t *StarTimer) Stop() error {
|
|
t.mu.Lock()
|
|
defer t.mu.Unlock()
|
|
if !t.running {
|
|
return nil
|
|
}
|
|
t.running = false
|
|
t.stopFn()
|
|
if t.timer != nil {
|
|
t.timer.Stop()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (t *StarTimer) NextTimer() time.Time {
|
|
if t.base.Before(time.Now()) {
|
|
return t.parseNextDate(time.Now(), true)
|
|
}
|
|
return t.parseNextDate(t.base, true)
|
|
}
|
|
|
|
func (t *StarTimer) NextTimerAfterDate(date time.Time) time.Time {
|
|
return t.parseNextDate(date, true)
|
|
}
|
|
|
|
func (t *StarTimer) ExportRepeats() (string, error) {
|
|
var rep []Repeats
|
|
for _, r := range t.repeat {
|
|
rep = append(rep, *r)
|
|
}
|
|
data, err := json.Marshal(rep)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
return string(data), nil
|
|
}
|
|
|
|
func (t *StarTimer) ImportRepeats(r string) error {
|
|
t.mu.Lock()
|
|
defer t.mu.Unlock()
|
|
if t.running {
|
|
return errors.New("cannot import repeats to already running timer")
|
|
}
|
|
var rep []Repeats
|
|
err := json.Unmarshal([]byte(r), &rep)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.repeat = make([]*Repeats, 0, len(rep))
|
|
for _, v := range rep {
|
|
if err = t.repeatsCheck(&v); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
for _, v := range rep {
|
|
t.repeat = append(t.repeat, &v)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (t *StarTimer) BaseDate() time.Time {
|
|
return t.base
|
|
}
|
|
func (t *StarTimer) SetBaseDate(date time.Time) {
|
|
t.base = date
|
|
}
|
|
|
|
func (t *StarTimer) StaticMode() bool {
|
|
return t.staticMode
|
|
}
|
|
func (t *StarTimer) SetStaticMode(s bool) {
|
|
t.staticMode = s
|
|
}
|
|
|
|
func (t *StarTimer) ResetWithRepeat(base time.Time, repeat []*Repeats) error {
|
|
t.Stop()
|
|
t.base = base
|
|
for _, v := range repeat {
|
|
if err := t.repeatsCheck(v); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
t.repeat = repeat
|
|
return t.Run()
|
|
}
|
|
|
|
func (t *StarTimer) Repeats() []*Repeats {
|
|
return t.repeat
|
|
}
|
|
|
|
func (t *StarTimer) runAsStaticMode() error {
|
|
t.mu.Lock()
|
|
defer t.mu.Unlock()
|
|
if t.running {
|
|
return nil
|
|
}
|
|
for _, v := range t.repeat {
|
|
if err := t.repeatsCheck(v); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
t.base = time.Now()
|
|
base := t.base
|
|
t.nextDate = t.parseNextDate(base, false)
|
|
if t.nextDate.Before(time.Now()) {
|
|
return errors.New("Invalid Timer Options,Please Check")
|
|
}
|
|
t.running = true
|
|
t.stopCtx, t.stopFn = context.WithCancel(context.Background())
|
|
go func() {
|
|
for {
|
|
if t.runLimit > 0 && t.runCount >= t.runLimit {
|
|
t.Stop()
|
|
}
|
|
now := time.Now()
|
|
t.nextDate = t.parseNextDate(now, false)
|
|
if t.nextDate.Before(now) || t.runLimit > 0 && t.runCount+1 >= t.runLimit {
|
|
t.Stop()
|
|
}
|
|
t.mu.Lock()
|
|
t.timer = time.NewTimer(t.nextDate.Sub(now))
|
|
t.mu.Unlock()
|
|
select {
|
|
case <-t.timer.C:
|
|
t.runCount++
|
|
for _, fn := range t.tasks {
|
|
go fn()
|
|
}
|
|
if !t.running {
|
|
return
|
|
}
|
|
case <-t.stopCtx.Done():
|
|
return
|
|
}
|
|
}
|
|
}()
|
|
return nil
|
|
}
|
|
|
|
func (t *StarTimer) Run() error {
|
|
if t.staticMode {
|
|
return t.runAsStaticMode()
|
|
}
|
|
t.mu.Lock()
|
|
defer t.mu.Unlock()
|
|
if t.running {
|
|
return nil
|
|
}
|
|
for _, v := range t.repeat {
|
|
if err := t.repeatsCheck(v); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
base := time.Now()
|
|
if t.base.After(base) {
|
|
base = t.base
|
|
}
|
|
t.nextDate = t.parseNextDate(base, false)
|
|
if t.nextDate.Before(time.Now()) {
|
|
return errors.New("Invalid Timer Options,Please Check")
|
|
}
|
|
t.running = true
|
|
t.stopCtx, t.stopFn = context.WithCancel(context.Background())
|
|
go func() {
|
|
for {
|
|
if t.runLimit > 0 && t.runCount >= t.runLimit {
|
|
t.Stop()
|
|
}
|
|
now := time.Now()
|
|
t.mu.Lock()
|
|
t.timer = time.NewTimer(t.nextDate.Sub(now))
|
|
t.mu.Unlock()
|
|
select {
|
|
case <-t.timer.C:
|
|
t.runCount++
|
|
t.nextDate = t.parseNextDate(t.nextDate, false)
|
|
if t.nextDate.Before(now) || t.runLimit > 0 && t.runCount >= t.runLimit {
|
|
t.Stop()
|
|
}
|
|
for _, fn := range t.tasks {
|
|
go fn()
|
|
}
|
|
if !t.running {
|
|
return
|
|
}
|
|
case <-t.stopCtx.Done():
|
|
return
|
|
}
|
|
}
|
|
}()
|
|
return nil
|
|
}
|
|
|
|
func (t *StarTimer) parseNextDate(base time.Time, isMock bool) time.Time {
|
|
if len(t.repeat) == 0 {
|
|
return time.Time{}
|
|
}
|
|
var dates []time.Time
|
|
for _, d := range t.repeat {
|
|
if d == nil {
|
|
continue
|
|
}
|
|
if d.Every {
|
|
dates = append(dates, t.parseEveryNextDate(base, d, isMock)...)
|
|
} else {
|
|
dates = append(dates, t.parseStaticNextDate(base, d, false))
|
|
}
|
|
}
|
|
sort.SliceStable(dates, func(i, j int) bool {
|
|
return dates[i].UnixNano() < dates[j].UnixNano()
|
|
})
|
|
if len(dates) == 0 {
|
|
return time.Time{}
|
|
}
|
|
var bt int64
|
|
if !isMock {
|
|
bt = time.Now().UnixNano()
|
|
} else {
|
|
bt = base.UnixNano()
|
|
}
|
|
for _, v := range dates {
|
|
if v.UnixNano() > bt {
|
|
return v
|
|
}
|
|
}
|
|
return time.Time{}
|
|
}
|
|
|
|
func (t *StarTimer) parseStaticNextDate(base time.Time, r *Repeats, recall bool) time.Time {
|
|
base = time.Date(base.Year(), base.Month(), base.Day(), base.Hour(), base.Minute(), base.Second(), 0, base.Location())
|
|
var targets []time.Time
|
|
var uniqueRepeat [][]Repeat
|
|
selectMap := make(map[Unit][]Repeat)
|
|
{
|
|
for _, d := range r.Repeat {
|
|
selectMap[d.Unit] = append(selectMap[d.Unit], d)
|
|
}
|
|
for key, val := range selectMap {
|
|
if key == STAR_WEEK {
|
|
continue
|
|
}
|
|
defUnikey := make([][]Repeat, 0, 1024)
|
|
for _, vs := range val {
|
|
if len(uniqueRepeat) == 0 {
|
|
defUnikey = append(defUnikey, []Repeat{vs})
|
|
} else {
|
|
for k := range uniqueRepeat {
|
|
tmp := make([]Repeat, len(uniqueRepeat[k])+1)
|
|
copy(tmp, append(uniqueRepeat[k], vs))
|
|
defUnikey = append(defUnikey, tmp)
|
|
}
|
|
}
|
|
}
|
|
if len(defUnikey) > 0 {
|
|
uniqueRepeat = defUnikey
|
|
}
|
|
}
|
|
}
|
|
for _, task := range uniqueRepeat {
|
|
sort.SliceStable(task, func(i, j int) bool {
|
|
return task[i].Unit < task[j].Unit
|
|
})
|
|
target := base
|
|
veryDay, veryMonth := 0, 0 //验证日期
|
|
if !r.Every { //固定日期
|
|
for _, d := range task {
|
|
switch d.Unit {
|
|
case STAR_SECOND:
|
|
sub := int(d.Value) - target.Second()
|
|
if sub < 0 {
|
|
sub += 60
|
|
}
|
|
target = target.Add(time.Second * time.Duration(sub))
|
|
case STAR_MINUTE:
|
|
sub := int(d.Value) - target.Minute()
|
|
if sub < 0 {
|
|
sub += 60
|
|
}
|
|
target = target.Add(time.Minute * time.Duration(sub))
|
|
case STAR_HOUR:
|
|
sub := int(d.Value) - target.Hour()
|
|
if sub < 0 {
|
|
sub += 24
|
|
}
|
|
target = target.Add(time.Hour * time.Duration(sub))
|
|
case STAR_DAY:
|
|
veryDay = int(d.Value)
|
|
sub := int(d.Value) - target.Day()
|
|
if sub >= 0 {
|
|
target = target.Add(time.Hour * 24 * time.Duration(sub))
|
|
continue
|
|
}
|
|
target = time.Date(target.Year(), target.Month()+1, int(d.Value), target.Hour(), target.Minute(), target.Second(), 0, target.Location())
|
|
case STAR_MONTH:
|
|
veryMonth = int(d.Value)
|
|
sub := int(d.Value) - int(target.Month())
|
|
if sub < 0 {
|
|
sub += 12
|
|
}
|
|
target = target.AddDate(0, sub, 0)
|
|
case STAR_YEAR:
|
|
sub := int(d.Value) - int(target.Year())
|
|
if sub < 0 {
|
|
continue
|
|
}
|
|
target = target.AddDate(sub, 0, 0)
|
|
}
|
|
}
|
|
}
|
|
if target.UnixNano() == base.UnixNano() && veryDay == veryMonth && veryDay == 0 {
|
|
target = target.Add(time.Hour * 24)
|
|
}
|
|
if (veryDay != 0 && target.Day() != veryDay) || (veryMonth != 0 && int(target.Month()) != veryMonth) {
|
|
continue
|
|
}
|
|
if target.UnixNano() == base.UnixNano() && !recall {
|
|
continue
|
|
}
|
|
targets = append(targets, target)
|
|
|
|
}
|
|
sort.SliceStable(targets, func(i, j int) bool {
|
|
return targets[i].UnixNano() < targets[j].UnixNano()
|
|
})
|
|
for k, v := range targets {
|
|
if v.UnixNano() > base.UnixNano() || (recall && v.UnixNano() == base.UnixNano()) {
|
|
targets = targets[k:]
|
|
break
|
|
}
|
|
}
|
|
if val, ok := selectMap[STAR_WEEK]; ok {
|
|
if len(targets) > 0 {
|
|
for _, week := range val {
|
|
if int(targets[0].Weekday()) == int(week.Value) {
|
|
return targets[0]
|
|
}
|
|
}
|
|
nextBase := targets[0]
|
|
if nextBase == base {
|
|
nextBase = time.Date(targets[0].Year(), targets[0].Month(), targets[0].Day(), 0, 0, 0, 0, targets[0].Location())
|
|
nextBase = nextBase.Add(time.Hour * 24)
|
|
}
|
|
return t.parseStaticNextDate(nextBase, r, true)
|
|
}
|
|
}
|
|
if len(targets) > 0 {
|
|
return targets[0]
|
|
}
|
|
return time.Time{}
|
|
}
|
|
|
|
func (t *StarTimer) parseEveryNextDate(target time.Time, r *Repeats, isMock bool) []time.Time {
|
|
var res []time.Time
|
|
if r.Every { //定期日期
|
|
for idx, d := range r.Repeat {
|
|
if d.baseDate.Unix() == -62135596800 {
|
|
d.baseDate = t.base
|
|
if !isMock {
|
|
r.Repeat[idx] = d
|
|
}
|
|
}
|
|
if d.baseDate.After(target) {
|
|
res = append(res, d.baseDate)
|
|
continue
|
|
}
|
|
switch d.Unit {
|
|
case STAR_SECOND:
|
|
for {
|
|
d.baseDate = d.baseDate.Add(time.Second * time.Duration(int(d.Value)))
|
|
if d.baseDate.After(target) {
|
|
if !isMock {
|
|
r.Repeat[idx] = d
|
|
}
|
|
break
|
|
}
|
|
}
|
|
res = append(res, d.baseDate)
|
|
case STAR_MINUTE:
|
|
for {
|
|
d.baseDate = d.baseDate.Add(time.Minute * time.Duration(int(d.Value)))
|
|
if d.baseDate.After(target) {
|
|
if !isMock {
|
|
r.Repeat[idx] = d
|
|
}
|
|
break
|
|
}
|
|
}
|
|
res = append(res, d.baseDate)
|
|
case STAR_HOUR:
|
|
for {
|
|
d.baseDate = d.baseDate.Add(time.Hour * time.Duration(int(d.Value)))
|
|
if d.baseDate.After(target) {
|
|
if !isMock {
|
|
r.Repeat[idx] = d
|
|
}
|
|
break
|
|
}
|
|
}
|
|
res = append(res, d.baseDate)
|
|
case STAR_DAY:
|
|
for {
|
|
d.baseDate = d.baseDate.Add(time.Hour * 24 * time.Duration(int(d.Value)))
|
|
if d.baseDate.After(target) {
|
|
if !isMock {
|
|
r.Repeat[idx] = d
|
|
}
|
|
break
|
|
}
|
|
}
|
|
res = append(res, d.baseDate)
|
|
case STAR_MONTH:
|
|
for {
|
|
d.baseDate = d.baseDate.AddDate(0, int(d.Value), 0)
|
|
if d.baseDate.After(target) {
|
|
if !isMock {
|
|
r.Repeat[idx] = d
|
|
}
|
|
break
|
|
}
|
|
}
|
|
res = append(res, d.baseDate)
|
|
case STAR_YEAR:
|
|
for {
|
|
d.baseDate = d.baseDate.AddDate(int(d.Value), 0, 0)
|
|
if d.baseDate.After(target) {
|
|
if !isMock {
|
|
r.Repeat[idx] = d
|
|
}
|
|
break
|
|
}
|
|
}
|
|
res = append(res, d.baseDate)
|
|
}
|
|
}
|
|
}
|
|
return res
|
|
}
|