Rewrite scheduler (#89)

* scheduler: Rewrite

Author: sunshineplan

scheduler/clock.go

@@ -143,6 +143,10 @@ func (c Clock) IsMatched(t time.Time) bool {
 }
 
 func (c Clock) Next(t time.Time) (next time.Time) {
+	t = t.Truncate(time.Second)
+	if c.IsMatched(t) {
+		t = t.Add(time.Second)
+	}
 	year, month, day := t.Date()
 	var hour, min, sec int
 	if c.sec {
@@ -160,7 +164,7 @@ func (c Clock) Next(t time.Time) (next time.Time) {
 	} else {
 		hour = t.Hour()
 	}
-	switch next = time.Date(year, month, day, hour, min, sec, 0, t.Location()); t.Truncate(time.Second).Compare(next) {
+	switch next = time.Date(year, month, day, hour, min, sec, 0, t.Location()); t.Compare(next) {
 	case 1:
 		if !c.sec {
 			next = next.Add(-time.Duration(sec) * time.Second)
@@ -190,18 +194,6 @@ func (c Clock) Next(t time.Time) (next time.Time) {
 	}
 }
 
-func (c Clock) TickerDuration() time.Duration {
-	if !c.sec {
-		return time.Second
-	} else if !c.min {
-		return time.Minute
-	} else if !c.hour {
-		return time.Hour
-	} else {
-		return 24 * time.Hour
-	}
-}
-
 func (c Clock) String() string {
 	var hour, min, sec string
 	if !c.hour {
@@ -241,7 +233,7 @@ func (s clockSched) IsMatched(t time.Time) bool {
 
 func (s clockSched) Next(t time.Time) time.Time {
 	if s.IsMatched(t) {
-		return t
+		t = t.Add(time.Second)
 	}
 	start, end := s.start.Clock, s.end.Clock
 	for c := AtClock(t.Clock()); c.Compare(start) != -1 && c.Compare(end) != 1; c.Clock = c.Add(time.Second) {

scheduler/clock_test.go

@@ -18,9 +18,6 @@ func TestClock(t *testing.T) {
 		t.Error("expected false: got true")
 	}
 	s = ScheduleFromString("7:00")
-	if res := s.TickerDuration(); res != 24*time.Hour {
-		t.Errorf("expected 24h; got %v", res)
-	}
 	if res := s.Next(AtClock(6, 0, 0).Time()).Format("15:04:05"); res != "07:00:00" {
 		t.Errorf("expected 07:00:00; got %q", res)
 	}
@@ -34,11 +31,11 @@ func TestClockNext1(t *testing.T) {
 		expected time.Duration
 	}{
 		{AtClock(0, 0, 0), "00:00:00", 11*time.Hour + 29*time.Minute + 30*time.Second},
-		{AtClock(-1, -1, -1), "12:30:30", 0},
-		{AtClock(-1, -1, 30), "12:30:30", 0},
-		{AtClock(-1, 30, -1), "12:30:30", 0},
-		{AtClock(12, -1, -1), "12:30:30", 0},
-		{AtClock(12, -1, 30), "12:30:30", 0},
+		{AtClock(-1, -1, -1), "12:30:31", time.Second},
+		{AtClock(-1, -1, 30), "12:31:30", time.Minute},
+		{AtClock(-1, 30, -1), "12:30:31", time.Second},
+		{AtClock(12, -1, -1), "12:30:31", time.Second},
+		{AtClock(12, -1, 30), "12:31:30", time.Minute},
 		{AtClock(-1, -1, 15), "12:31:15", 45 * time.Second},
 		{AtClock(-1, -1, 45), "12:30:45", 15 * time.Second},
 		{AtClock(-1, 15, -1), "13:15:00", 44*time.Minute + 30*time.Second},
@@ -65,7 +62,7 @@ func TestClockNext2(t *testing.T) {
 		s     string
 		d     time.Duration
 	}{
-		{AtClock(0, 0, -1), AtClock(0, 0, 59).Time(), "00:00:59", 0},
+		{AtClock(0, 0, -1), AtClock(0, 0, 59).Time(), "00:00:00", 23*time.Hour + 59*time.Minute + time.Second},
 		{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},
@@ -81,34 +78,16 @@ func TestClockNext2(t *testing.T) {
 	}
 }
 
-func TestClockTickerDuration(t *testing.T) {
-	for _, testcase := range []struct {
-		clock    *Clock
-		expected time.Duration
-	}{
-		{AtClock(1, 0, 0), 24 * time.Hour},
-		{AtClock(-1, 2, 0), time.Hour},
-		{AtClock(0, -1, 3), time.Minute},
-		{AtClock(4, 0, -1), time.Second},
-		{AtClock(-1, 5, -1), time.Second},
-		{AtClock(-1, -1, -1), time.Second},
-	} {
-		if res := testcase.clock.TickerDuration(); res != testcase.expected {
-			t.Errorf("%s expected %v; got %v", testcase.clock, testcase.expected, res)
-		}
-	}
-}
-
 func TestClockSchedule(t *testing.T) {
 	s := ClockSchedule(AtHour(9).Minute(30), AtHour(15), 2*time.Minute)
 	for _, testcase := range []struct {
 		clock    *Clock
 		time     string
 		expected bool
 	}{
-		{AtClock(9, 30, 0), "09:30:00", true},
-		{AtClock(15, 0, 0), "15:00:00", true},
-		{AtClock(13, 0, 0), "13:00:00", true},
+		{AtClock(9, 30, 0), "09:32:00", true},
+		{AtClock(15, 0, 0), "09:30:00", true},
+		{AtClock(13, 0, 0), "13:02:00", true},
 		{ClockFromString("9:29"), "09:30:00", false},
 		{ClockFromString("9:31"), "09:32:00", false},
 		{ClockFromString("16:00:00"), "09:30:00", false},

scheduler/complex.go

@@ -16,7 +16,6 @@ var (
 type complexSched interface {
 	IsMatched(time.Time) bool
 	Next(time.Time) time.Time
-	TickerDuration() time.Duration
 	String() string
 
 	init(t time.Time)
@@ -69,15 +68,6 @@ func (s multiSched) Next(t time.Time) (next time.Time) {
 	return
 }
 
-func (s multiSched) TickerDuration() time.Duration {
-	if l := len(s); l == 0 {
-		return 0
-	} else if l == 1 {
-		return s[0].TickerDuration()
-	}
-	return time.Second
-}
-
 func (s multiSched) String() string {
 	switch len(s) {
 	case 0:
@@ -129,34 +119,17 @@ func (s condSched) Next(t time.Time) (next time.Time) {
 	} else if l == 1 {
 		return s[0].Next(t)
 	}
-	var start time.Time
-	var duration time.Duration
-	for _, s := range s {
-		if d := s.TickerDuration(); d > duration {
-			duration = d
-			start = s.Next(t)
-		} else if d == duration {
-			if next := s.Next(t); next.Before(start) {
-				start = next
-			}
-		}
+	if s.IsMatched(t) {
+		t = t.Add(time.Second)
 	}
-	for next = start; !s.IsMatched(next); next = next.Add(duration) {
+	for next = t.Truncate(time.Second); !s.IsMatched(next); next = next.Add(time.Second) {
 		if next.Sub(t) >= time.Hour*24*366 {
 			return time.Time{}
 		}
 	}
 	return
 }
 
-func (s condSched) TickerDuration() time.Duration {
-	var res time.Duration
-	for _, i := range s {
-		res = gcd(res, i.TickerDuration())
-	}
-	return res
-}
-
 func (s condSched) String() string {
 	switch len(s) {
 	case 0:

scheduler/complex_test.go

@@ -1,15 +1,9 @@
 package scheduler
 
-import (
-	"testing"
-	"time"
-)
+import "testing"
 
 func TestMultiSchedule(t *testing.T) {
 	s := MultiSchedule(AtHour(3), AtMinute(4), AtSecond(5))
-	if res := s.Next(time.Time{}).Format("15:04:05"); res != "00:00:05" {
-		t.Fatalf("expected 00:00:05: got %q", res)
-	}
 	for _, testcase := range []struct {
 		clock    *Clock
 		expected bool
@@ -25,14 +19,27 @@ func TestMultiSchedule(t *testing.T) {
 	}
 }
 
+func TestMultiScheduleNext(t *testing.T) {
+	s := MultiSchedule(AtHour(3), AtMinute(4), AtSecond(5))
+	for _, testcase := range []struct {
+		t    string
+		next string
+	}{
+		{"2000/01/01 00:00:00", "2000/01/01 00:00:05"},
+		{"2000/01/01 00:00:05", "2000/01/01 00:01:05"},
+		{"2000/01/01 00:03:05", "2000/01/01 00:04:00"},
+		{"2000/01/01 00:04:00", "2000/01/01 00:04:05"},
+		{"2000/01/01 02:59:05", "2000/01/01 03:00:00"},
+		{"2000/01/01 03:00:00", "2000/01/01 03:00:05"},
+	} {
+		if res := s.Next(parse(testcase.t)).Format(format); res != testcase.next {
+			t.Errorf("%s expected %v; got %v", testcase.t, testcase.next, res)
+		}
+	}
+}
+
 func TestConditionSchedule(t *testing.T) {
 	s := ConditionSchedule(Weekdays, MultiSchedule(AtClock(9, 30, 0), AtHour(15)))
-	if d := s.TickerDuration(); d != time.Second {
-		t.Fatalf("expected 1s: got %s", d)
-	}
-	if res := s.Next(time.Time{}).Format("15:04:05"); res != "09:30:00" {
-		t.Fatalf("expected 00:00:01: got %q", res)
-	}
 	for _, testcase := range []struct {
 		clock    *Clock
 		expected bool
@@ -47,3 +54,20 @@ func TestConditionSchedule(t *testing.T) {
 		}
 	}
 }
+
+func TestConditionScheduleNext(t *testing.T) {
+	s := ConditionSchedule(Weekdays, MultiSchedule(AtClock(9, 30, 0), AtHour(15)))
+	for _, testcase := range []struct {
+		t    string
+		next string
+	}{
+		{"2000/01/01 00:00:00", "2000/01/03 09:30:00"},
+		{"2000/01/03 09:30:00", "2000/01/03 15:00:00"},
+		{"2000/01/03 15:00:00", "2000/01/04 09:30:00"},
+		{"2000/01/07 15:00:00", "2000/01/10 09:30:00"},
+	} {
+		if res := s.Next(parse(testcase.t)).Format(format); res != testcase.next {
+			t.Errorf("%s expected %v; got %v", testcase.t, testcase.next, res)
+		}
+	}
+}

scheduler/init.go

@@ -0,0 +1,40 @@
+package scheduler
+
+import (
+	"time"
+
+	"github.com/sunshineplan/utils/container"
+)
+
+var subscriber = container.NewMap[chan Event, time.Time]()
+
+type Event struct {
+	Time   time.Time
+	Goal   time.Time
+	Missed bool
+}
+
+func init() {
+	go func() {
+		for t := range time.NewTicker(time.Second).C {
+			t = t.Truncate(time.Second)
+			go subscriber.Range(func(k chan Event, v time.Time) bool {
+				switch v.Compare(t) {
+				case -1:
+					k <- Event{t, v, true}
+				case 0:
+					k <- Event{t, v, false}
+				}
+				return true
+			})
+		}
+	}()
+}
+
+func subscribe(t time.Time, c chan Event) {
+	subscriber.Swap(c, t.Truncate(time.Second))
+}
+
+func unsubscribe(c chan Event) {
+	subscriber.Delete(c)
+}