scheduler: Update (#47)

Author: sunshineplan

ptr.go

@@ -0,0 +1,3 @@
+package utils
+
+func Ptr[T any](t T) *T { return &t }

scheduler/clock.go

@@ -50,7 +50,7 @@ func AtClock(hour, min, sec int) *Clock {
 	return &c
 }
 
-func FullClock() *Clock { return AtClock(-1, -1, -1) }
+func FullClock() *Clock { return new(Clock) }
 
 func AtHour(hour int) *Clock {
 	return AtClock(hour, 0, 0)

scheduler/clock_test.go

@@ -26,7 +26,7 @@ func TestClock(t *testing.T) {
 	}
 }
 
-func TestClockNext(t *testing.T) {
+func TestClockNext1(t *testing.T) {
 	ct := AtClock(12, 30, 30).Time()
 	for _, testcase := range []struct {
 		clock    *Clock
@@ -58,6 +58,29 @@ func TestClockNext(t *testing.T) {
 	}
 }
 
+func TestClockNext2(t *testing.T) {
+	for _, testcase := range []struct {
+		clock *Clock
+		t     time.Time
+		s     string
+		d     time.Duration
+	}{
+		{AtClock(0, 0, -1), AtClock(0, 0, 59).Time(), "00:00:59", 0},
+		{AtClock(0, -1, 0), AtClock(0, 59, 59).Time(), "00:00:00", 23*time.Hour + time.Second},
+		{AtClock(-1, 0, 0), AtClock(23, 59, 0).Time(), "00:00:00", time.Minute},
+		{AtClock(0, -1, 0), AtClock(0, 0, 59).Time(), "00:01:00", time.Second},
+		{AtClock(0, 0, -1), AtClock(23, 59, 59).Time(), "00:00:00", time.Second},
+	} {
+		next := testcase.clock.Next(testcase.t)
+		if res := next.Format("15:04:05"); res != testcase.s {
+			t.Errorf("%s expected %q; got %q", testcase.clock, testcase.s, res)
+		}
+		if res := next.Sub(testcase.t); res != testcase.d {
+			t.Errorf("%s expected %v; got %v", testcase.clock, testcase.d, res)
+		}
+	}
+}
+
 func TestClockTickerDuration(t *testing.T) {
 	for _, testcase := range []struct {
 		clock    *Clock

scheduler/notify.go

@@ -6,7 +6,7 @@ import (
 )
 
 var (
-	subscriber = make(map[chan struct{}]struct{})
+	subscriber = make(map[chan time.Time]struct{})
 	mu         sync.Mutex
 )
 
@@ -20,7 +20,7 @@ func init() {
 				if sub := t.Sub(last.Add(time.Second)); sub >= 10*time.Millisecond || sub <= -10*time.Millisecond {
 					mu.Lock()
 					for k := range subscriber {
-						k <- struct{}{}
+						k <- t
 					}
 					mu.Unlock()
 				}
@@ -30,13 +30,13 @@ func init() {
 	}()
 }
 
-func subscribeNotify(c chan struct{}) {
+func subscribeNotify(c chan time.Time) {
 	mu.Lock()
 	defer mu.Unlock()
 	subscriber[c] = struct{}{}
 }
 
-func unsubscribeNotify(c chan struct{}) {
+func unsubscribeNotify(c chan time.Time) {
 	mu.Lock()
 	defer mu.Unlock()
 	delete(subscriber, c)

scheduler/schedule.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"time"
 
+	"github.com/sunshineplan/utils"
 	"github.com/sunshineplan/utils/clock"
 )
 
@@ -52,6 +53,9 @@ type sched struct {
 }
 
 func NewSchedule(year int, month time.Month, day int, clock *Clock) Schedule {
+	if clock == nil {
+		clock = new(Clock)
+	}
 	return sched{year, month, day, clock}
 }
 
@@ -69,25 +73,16 @@ func (s sched) IsMatched(t time.Time) bool {
 	if (s.year == 0 || s.year == year) &&
 		(s.month == 0 || s.month == month) &&
 		(s.day == 0 || s.day == day) {
-		if s.clock == nil {
-			s.clock = &Clock{}
-		}
 		return s.clock.IsMatched(t)
 	}
 	return false
 }
 
 func (s sched) Next(t time.Time) time.Time {
-	if s.clock == nil {
-		s.clock = &Clock{}
-	}
 	return s.clock.Next(t)
 }
 
 func (s sched) TickerDuration() time.Duration {
-	if s.clock == nil {
-		return 24 * time.Hour
-	}
 	return s.clock.TickerDuration()
 }
 
@@ -108,9 +103,6 @@ func (s sched) String() string {
 	} else {
 		day = fmt.Sprintf("%02d", s.day)
 	}
-	if s.clock == nil {
-		s.clock = &Clock{}
-	}
 	return fmt.Sprintf("%s/%s/%s %s", year, month, day, s.clock)
 }
 
@@ -121,6 +113,9 @@ type weekSched struct {
 }
 
 func ISOWeekSchedule(year int, week int, weekday *time.Weekday, clock *Clock) Schedule {
+	if clock == nil {
+		clock = new(Clock)
+	}
 	return weekSched{year, week, weekday, clock}
 }
 
@@ -130,25 +125,16 @@ func (s weekSched) IsMatched(t time.Time) bool {
 	if (s.year == 0 || s.year == year) &&
 		(s.week == 0 || s.week == week) &&
 		(s.weekday == nil || *s.weekday == weekday) {
-		if s.clock == nil {
-			s.clock = &Clock{}
-		}
 		return s.clock.IsMatched(t)
 	}
 	return false
 }
 
 func (s weekSched) Next(t time.Time) time.Time {
-	if s.clock == nil {
-		s.clock = &Clock{}
-	}
 	return s.clock.Next(t)
 }
 
 func (s weekSched) TickerDuration() time.Duration {
-	if s.clock == nil {
-		return 24 * time.Hour
-	}
 	return s.clock.TickerDuration()
 }
 
@@ -169,9 +155,6 @@ func (s weekSched) String() string {
 	} else {
 		weekday = fmt.Sprint(s.weekday)
 	}
-	if s.clock == nil {
-		s.clock = &Clock{}
-	}
 	return fmt.Sprintf("%s/ISOWeek:%s/Weekday:%s %s", year, week, weekday, s.clock)
 }
 
@@ -183,17 +166,16 @@ type weekdaySched struct {
 }
 
 func WeekdaySchedule(year int, month time.Month, weekday *time.Weekday, clock *Clock) Schedule {
+	if clock == nil {
+		clock = new(Clock)
+	}
 	return weekdaySched{year, month, weekday, clock}
 }
 
-func ptrWeekday(weekday time.Weekday) *time.Weekday {
-	return &weekday
-}
-
 func Weekday(weekday ...time.Weekday) Schedule {
 	var s multiSched
 	for _, weekday := range weekday {
-		s = append(s, WeekdaySchedule(0, 0, ptrWeekday(weekday), FullClock()))
+		s = append(s, WeekdaySchedule(0, 0, utils.Ptr(weekday), FullClock()))
 	}
 	return s
 }
@@ -209,25 +191,16 @@ func (s weekdaySched) IsMatched(t time.Time) bool {
 	if (s.year == 0 || s.year == year) &&
 		(s.month == 0 || s.month == month) &&
 		(s.weekday == nil || *s.weekday == weekday) {
-		if s.clock == nil {
-			s.clock = &Clock{}
-		}
 		return s.clock.IsMatched(t)
 	}
 	return false
 }
 
 func (s weekdaySched) Next(t time.Time) time.Time {
-	if s.clock == nil {
-		s.clock = &Clock{}
-	}
 	return s.clock.Next(t)
 }
 
 func (s weekdaySched) TickerDuration() time.Duration {
-	if s.clock == nil {
-		return 24 * time.Hour
-	}
 	return s.clock.TickerDuration()
 }
 
@@ -248,9 +221,6 @@ func (s weekdaySched) String() string {
 	} else {
 		weekday = fmt.Sprint(s.weekday)
 	}
-	if s.clock == nil {
-		s.clock = &Clock{}
-	}
 	return fmt.Sprintf("%s/%s/Weekday:%s %s", year, month, weekday, s.clock)
 }
 

scheduler/scheduler.go

@@ -15,7 +15,7 @@ var (
 
 type Scheduler struct {
 	mu     sync.Mutex
-	notify chan struct{}
+	notify chan time.Time
 
 	timer  *time.Timer
 	ticker *time.Ticker
@@ -29,7 +29,7 @@ type Scheduler struct {
 }
 
 func NewScheduler() *Scheduler {
-	return &Scheduler{notify: make(chan struct{}, 1), tc: make(chan time.Time, 1)}
+	return &Scheduler{notify: make(chan time.Time, 1), tc: make(chan time.Time, 1)}
 }
 
 func (sched *Scheduler) At(schedules ...Schedule) *Scheduler {
@@ -86,18 +86,18 @@ func (sched *Scheduler) init(d time.Duration) error {
 }
 
 func (sched *Scheduler) checkMatched(t time.Time) {
+	sched.mu.Lock()
+	defer sched.mu.Unlock()
 	if sched.sched.IsMatched(t) {
 		sched.tc <- t
 	} else if sched.sched.TickerDuration() >= time.Minute {
 		if minus1s := t.Add(-time.Second); sched.sched.IsMatched(minus1s) {
 			sched.tc <- minus1s
-			sched.notify <- struct{}{}
+			sched.notify <- t
 		} else if plus1s := t.Add(time.Second); sched.sched.IsMatched(plus1s) {
 			sched.tc <- plus1s
-			go func() {
-				time.Sleep(2 * time.Second)
-				sched.notify <- struct{}{}
-			}()
+			time.Sleep(2 * time.Second)
+			sched.notify <- time.Now()
 		}
 	}
 }
@@ -112,14 +112,11 @@ func (sched *Scheduler) newTimer(first, duration time.Duration) {
 			for {
 				select {
 				case t := <-sched.ticker.C:
-					sched.mu.Lock()
 					sched.checkMatched(t)
-					sched.mu.Unlock()
-				case <-sched.notify:
+				case t := <-sched.notify:
 					sched.ticker.Stop()
 					sched.mu.Lock()
 					defer sched.mu.Unlock()
-					t := time.Now()
 					sched.newTimer(sched.sched.Next(t).Sub(t), duration)
 					return
 				case <-sched.ctx.Done():
@@ -128,17 +125,14 @@ func (sched *Scheduler) newTimer(first, duration time.Duration) {
 				}
 			}
 		}()
-		sched.mu.Lock()
-		defer sched.mu.Unlock()
 		sched.checkMatched(now)
 	})
 	go func() {
 		for {
 			select {
-			case <-sched.notify:
+			case t := <-sched.notify:
 				sched.mu.Lock()
 				if sched.timer.Stop() {
-					t := time.Now()
 					sched.timer.Reset(sched.sched.Next(t).Sub(t))
 				}
 				sched.mu.Unlock()

scheduler/scheduler_test.go

@@ -57,7 +57,7 @@ func TestTickerScheduler2(t *testing.T) {
 	}
 	s.mu.Unlock()
 
-	s.notify <- struct{}{}
+	s.notify <- time.Now()
 	time.Sleep(500 * time.Millisecond)
 
 	s.mu.Lock()