package clock

import "k8s.io/klog/v2/internal/clock"

Index ¶

• type Clock
• type PassiveClock
• type RealClock
• func (RealClock) After(d time.Duration) <-chan time.Time
• func (RealClock) AfterFunc(d time.Duration, f func()) Timer
• func (RealClock) NewTicker(d time.Duration) Ticker
• func (RealClock) NewTimer(d time.Duration) Timer
• func (RealClock) Now() time.Time
• func (RealClock) Since(ts time.Time) time.Duration
• func (RealClock) Sleep(d time.Duration)
• func (RealClock) Tick(d time.Duration) <-chan time.Time
• type Ticker
• type Timer
• type WithDelayedExecution
• type WithTicker
• type WithTickerAndDelayedExecution

Types ¶

type Clock ¶

type Clock interface {
	PassiveClock
	// After returns the channel of a new Timer.
	// This method does not allow to free/GC the backing timer before it fires. Use
	// NewTimer instead.
	After(d time.Duration) <-chan time.Time
	// NewTimer returns a new Timer.
	NewTimer(d time.Duration) Timer
	// Sleep sleeps for the provided duration d.
	// Consider making the sleep interruptible by using 'select' on a context channel and a timer channel.
	Sleep(d time.Duration)
	// Tick returns the channel of a new Ticker.
	// This method does not allow to free/GC the backing ticker. Use
	// NewTicker from WithTicker instead.
	Tick(d time.Duration) <-chan time.Time
}

Clock allows for injecting fake or real clocks into code that needs to do arbitrary things based on time.

type PassiveClock ¶

type PassiveClock interface {
	Now() time.Time
	Since(time.Time) time.Duration
}

PassiveClock allows for injecting fake or real clocks into code that needs to read the current time but does not support scheduling activity in the future.

type RealClock ¶

type RealClock struct{}

RealClock really calls time.Now()

func (RealClock) After ¶

func (RealClock) After(d time.Duration) <-chan time.Time

After is the same as time.After(d). This method does not allow to free/GC the backing timer before it fires. Use NewTimer instead.

func (RealClock) AfterFunc ¶

func (RealClock) AfterFunc(d time.Duration, f func()) Timer

AfterFunc is the same as time.AfterFunc(d, f).

func (RealClock) NewTicker ¶

func (RealClock) NewTicker(d time.Duration) Ticker

NewTicker returns a new Ticker.

func (RealClock) NewTimer ¶

func (RealClock) NewTimer(d time.Duration) Timer

NewTimer is the same as time.NewTimer(d)

func (RealClock) Now ¶

func (RealClock) Now() time.Time

Now returns the current time.

func (RealClock) Since ¶

func (RealClock) Since(ts time.Time) time.Duration

Since returns time since the specified timestamp.

func (RealClock) Sleep ¶

func (RealClock) Sleep(d time.Duration)

Sleep is the same as time.Sleep(d) Consider making the sleep interruptible by using 'select' on a context channel and a timer channel.

func (RealClock) Tick ¶

func (RealClock) Tick(d time.Duration) <-chan time.Time

Tick is the same as time.Tick(d) This method does not allow to free/GC the backing ticker. Use NewTicker instead.

type Ticker ¶

type Ticker interface {
	C() <-chan time.Time
	Stop()
}

Ticker defines the Ticker interface.

type Timer ¶

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

Timer allows for injecting fake or real timers into code that needs to do arbitrary things based on time.

type WithDelayedExecution ¶

type WithDelayedExecution interface {
	Clock
	// AfterFunc executes f in its own goroutine after waiting
	// for d duration and returns a Timer whose channel can be
	// closed by calling Stop() on the Timer.
	AfterFunc(d time.Duration, f func()) Timer
}

WithDelayedExecution allows for injecting fake or real clocks into code that needs to make use of AfterFunc functionality.

type WithTicker ¶

type WithTicker interface {
	Clock
	// NewTicker returns a new Ticker.
	NewTicker(time.Duration) Ticker
}

WithTicker allows for injecting fake or real clocks into code that needs to do arbitrary things based on time.

type WithTickerAndDelayedExecution ¶

type WithTickerAndDelayedExecution interface {
	WithTicker
	// AfterFunc executes f in its own goroutine after waiting
	// for d duration and returns a Timer whose channel can be
	// closed by calling Stop() on the Timer.
	AfterFunc(d time.Duration, f func()) Timer
}

WithTickerAndDelayedExecution allows for injecting fake or real clocks into code that needs Ticker and AfterFunc functionality

Source Files ¶

clock.go

Directories ¶