loki/vendor/github.com/coder/quartz/ticker.go

package quartz

import "time"

// A Ticker holds a channel that delivers “ticks” of a clock at intervals.
type Ticker struct {
	C <-chan time.Time
	//nolint: revive
	c             chan time.Time
	ticker        *time.Ticker   // realtime impl, if set
	d             time.Duration  // period, if set
	nxt           time.Time      // next tick time
	mock          *Mock          // mock clock, if set
	stopped       bool           // true if the ticker is not running
	internalTicks chan time.Time // used to deliver ticks to the runLoop goroutine

	// As of Go 1.23, ticker channels are unbuffered and guaranteed to block forever after a call to stop.
	//
	// When a mocked ticker fires, we don't want to block on a channel write, because it's fine for the code under test
	// not to be reading. That means we need to start a new goroutine to do the channel write (runLoop) if we are a
	// channel-based ticker.
	//
	// They also are not supposed to leak even if they are never read or stopped (Go runtime can garbage collect them).
	// We can't garbage-collect because we can't check if any other code besides the mock references, but we can ensure
	// that we don't leak goroutines so that the garbage collector can do its job when the mock is no longer
	// referenced. The channels below allow us to interrupt the runLoop goroutine.
	interrupt chan struct{}
}

func (t *Ticker) fire(tt time.Time) {
	t.mock.mu.Lock()
	defer t.mock.mu.Unlock()
	if t.stopped {
		return
	}
	for !t.nxt.After(t.mock.cur) {
		t.nxt = t.nxt.Add(t.d)
	}
	t.mock.recomputeNextLocked()
	if t.interrupt != nil { // implies runLoop is still going.
		t.internalTicks <- tt
	}
}

func (t *Ticker) next() time.Time {
	return t.nxt
}

// Stop turns off a ticker. After Stop, no more ticks will be sent. Stop does
// not close the channel, to prevent a concurrent goroutine reading from the
// channel from seeing an erroneous "tick".
func (t *Ticker) Stop(tags ...string) {
	if t.ticker != nil {
		t.ticker.Stop()
		return
	}
	t.mock.mu.Lock()
	defer t.mock.mu.Unlock()
	c := newCall(clockFunctionTickerStop, tags)
	t.mock.matchCallLocked(c)
	defer close(c.complete)
	t.mock.removeEventLocked(t)
	t.stopped = true
	// check if we've already fired, and if so, interrupt it.
	if t.interrupt != nil {
		<-t.interrupt
		t.interrupt = nil
	}
}

// Reset stops a ticker and resets its period to the specified duration. The
// next tick will arrive after the new period elapses. The duration d must be
// greater than zero; if not, Reset will panic.
func (t *Ticker) Reset(d time.Duration, tags ...string) {
	if t.ticker != nil {
		t.ticker.Reset(d)
		return
	}
	t.mock.mu.Lock()
	defer t.mock.mu.Unlock()
	c := newCall(clockFunctionTickerReset, tags, withDuration(d))
	t.mock.matchCallLocked(c)
	defer close(c.complete)
	t.nxt = t.mock.cur.Add(d)
	t.d = d
	if t.stopped {
		t.stopped = false
		t.mock.addEventLocked(t)
	} else {
		t.mock.recomputeNextLocked()
	}
	if t.interrupt == nil {
		t.startRunLoopLocked()
	}
}

func (t *Ticker) runLoop(interrupt chan struct{}) {
	defer close(interrupt)
outer:
	for {
		select {
		case tt := <-t.internalTicks:
			for {
				select {
				case t.c <- tt:
					continue outer
				case <-t.internalTicks:
					// Discard future ticks until we can send this one.
				case interrupt <- struct{}{}:
					return
				}
			}
		case interrupt <- struct{}{}:
			return
		}
	}
}

func (t *Ticker) startRunLoopLocked() {
	// assert some assumptions. If these fire, it is a bug in Quartz itself.
	if t.interrupt != nil {
		t.mock.tb.Error("called startRunLoopLocked when interrupt suggests we are already running")
	}
	interrupt := make(chan struct{})
	t.interrupt = interrupt
	go t.runLoop(interrupt)
}

func newMockTickerLocked(m *Mock, d time.Duration) *Ticker {
	// no buffer follows Go 1.23+ behavior
	ticks := make(chan time.Time)
	t := &Ticker{
		C:             ticks,
		c:             ticks,
		d:             d,
		nxt:           m.cur.Add(d),
		mock:          m,
		internalTicks: make(chan time.Time),
	}
	m.addEventLocked(t)
	m.tb.Cleanup(func() {
		m.mu.Lock()
		defer m.mu.Unlock()
		if t.interrupt != nil {
			<-t.interrupt
			t.interrupt = nil
		}
	})
	t.startRunLoopLocked()
	return t
}