clock.go

package cron

import (
	"time"
	"github.com/banbox/bntp"
)

type Timer interface {
	Stop() bool
	Reset(d time.Duration) bool
	Chan() <-chan time.Time
}

type FireableTimer interface {
	Timer
	Fire()
}

type Clock interface {
	Now() time.Time
	Timer(time.Time) Timer
	SetTime(time.Time) bool
}

type DefaultClock struct {
	location *time.Location
}

func NewDefaultClock(location *time.Location) *DefaultClock {
	if location == nil {
		location = time.Local
	}
	return &DefaultClock{
		location: location,
	}
}

func (c *DefaultClock) Now() time.Time {
	return time.Now().In(c.location)
}

func (c *DefaultClock) Timer(t time.Time) Timer {
	return NewStdTimer(time.NewTimer(t.Sub(c.Now())))
}

func (c *DefaultClock) SetTime(t time.Time) bool {
	return false
}

type StdTimer struct {
	*time.Timer
}

// NewStdTimer creates a Timer with system clock.
func NewStdTimer(t *time.Timer) *StdTimer {
	return &StdTimer{
		Timer: t,
	}
}

func (t *StdTimer) Chan() <-chan time.Time {
	return t.C
}

type CustomTimer struct {
	*time.Timer
	clock    Clock
	expireAt time.Time
	c        chan time.Time
}

// NewCustomTimer creates a Timer with custom clock.
func NewCustomTimer(d time.Duration, clock Clock) *CustomTimer {
	ct := &CustomTimer{
		Timer:    time.NewTimer(d),
		clock:    clock,
		expireAt: clock.Now().Add(d),
		c:        make(chan time.Time, 1),
	}
	go func() {
		<-ct.Timer.C
		ct.c <- ct.expireAt
	}()
	return ct
}

func (t *CustomTimer) Chan() <-chan time.Time {
	return t.c
}

func (t *CustomTimer) Stop() bool {
	return t.Timer.Stop()
}

func (t *CustomTimer) Reset(d time.Duration) bool {
	// Reset the underlying timer
	active := t.Timer.Reset(d)
	// Update the expiration time based on current clock time
	t.expireAt = t.clock.Now().Add(d)
	// Start a new goroutine to handle the reset timer
	go func() {
		<-t.Timer.C
		t.c <- t.expireAt
	}()
	return active
}

// NtpClock 实现 Clock 接口，使用 bntp 作为时间源
type NtpClock struct {
	location *time.Location
}

// NewNtpClock LangGlobal, LangZhCN, LangZhHK, LangZhTW, LangJaJP, LangKoKr, LangZhSg, LangNone(default)
func NewNtpClock(location *time.Location, code string) *NtpClock {
	if code != "" {
		bntp.LangCode = code
	}
	return &NtpClock{
		location: location,
	}
}

func (c *NtpClock) Now() time.Time {
	return bntp.Now().In(c.location)
}

func (c *NtpClock) Timer(t time.Time) Timer {
	duration := t.Sub(c.Now())
	return NewCustomTimer(duration, c)
}

func (c *NtpClock) SetTime(t time.Time) bool {
	// bntp clock cannot be set
	return false
}

type FakeTimer struct {
	clock  *FakeClock
	expire time.Time
	C      chan time.Time
	fired  bool
}

func (t *FakeTimer) Stop() bool {
	if t.fired {
		return false
	}
	t.fired = true
	return true
}

func (t *FakeTimer) Chan() <-chan time.Time {
	return t.C
}

func (t *FakeTimer) Reset(d time.Duration) bool {
	if t.fired {
		return false
	}
	t.expire = t.clock.Now().Add(d)
	return true
}

func (t *FakeTimer) Fire() {
	if t.fired {
		panic("timer already fired")
	}
	t.fired = true
	t.C <- t.expire
}

type FakeClock struct {
	location *time.Location
	current  time.Time
}

func NewFakeClock(location *time.Location, current time.Time) *FakeClock {
	return &FakeClock{
		location: location,
		current:  current.In(location),
	}
}

func (c *FakeClock) Now() time.Time {
	return c.current.In(c.location)
}

func (c *FakeClock) Timer(t time.Time) Timer {
	return &FakeTimer{
		clock:  c,
		expire: t,
		C:      make(chan time.Time),
	}
}

func (c *FakeClock) SetTime(t time.Time) bool {
	c.current = t
	return true
}