apimachinery: k8s.io/apimachinery/pkg/util/clock Index | Files

package clock

import "k8s.io/apimachinery/pkg/util/clock"

Index

Package Files

clock.go

type Clock Uses

type Clock interface {
    PassiveClock
    After(time.Duration) <-chan time.Time
    NewTimer(time.Duration) Timer
    Sleep(time.Duration)
    NewTicker(time.Duration) Ticker
}

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

type FakeClock Uses

type FakeClock struct {
    FakePassiveClock
    // contains filtered or unexported fields
}

FakeClock implements Clock, but returns an arbitrary time.

func NewFakeClock Uses

func NewFakeClock(t time.Time) *FakeClock

NewFakeClock returns a new FakeClock

func (*FakeClock) After Uses

func (f *FakeClock) After(d time.Duration) <-chan time.Time

After is the Fake version of time.After(d).

func (*FakeClock) HasWaiters Uses

func (f *FakeClock) HasWaiters() bool

HasWaiters returns true if After has been called on f but not yet satisfied (so you can write race-free tests).

func (*FakeClock) NewTicker Uses

func (f *FakeClock) NewTicker(d time.Duration) Ticker

NewTicker returns a new Ticker.

func (*FakeClock) NewTimer Uses

func (f *FakeClock) NewTimer(d time.Duration) Timer

NewTimer is the Fake version of time.NewTimer(d).

func (*FakeClock) SetTime Uses

func (f *FakeClock) SetTime(t time.Time)

SetTime sets the time on a FakeClock.

func (*FakeClock) Sleep Uses

func (f *FakeClock) Sleep(d time.Duration)

Sleep pauses the FakeClock for duration d.

func (*FakeClock) Step Uses

func (f *FakeClock) Step(d time.Duration)

Step moves clock by Duration, notifies anyone that's called After, Tick, or NewTimer

type FakePassiveClock Uses

type FakePassiveClock struct {
    // contains filtered or unexported fields
}

FakePassiveClock implements PassiveClock, but returns an arbitrary time.

func NewFakePassiveClock Uses

func NewFakePassiveClock(t time.Time) *FakePassiveClock

NewFakePassiveClock returns a new FakePassiveClock.

func (*FakePassiveClock) Now Uses

func (f *FakePassiveClock) Now() time.Time

Now returns f's time.

func (*FakePassiveClock) SetTime Uses

func (f *FakePassiveClock) SetTime(t time.Time)

SetTime sets the time on the FakePassiveClock.

func (*FakePassiveClock) Since Uses

func (f *FakePassiveClock) Since(ts time.Time) time.Duration

Since returns time since the time in f.

type IntervalClock Uses

type IntervalClock struct {
    Time     time.Time
    Duration time.Duration
}

IntervalClock implements Clock, but each invocation of Now steps the clock forward the specified duration

func (*IntervalClock) After Uses

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

After is currently unimplemented, will panic. TODO: make interval clock use FakeClock so this can be implemented.

func (*IntervalClock) NewTicker Uses

func (*IntervalClock) NewTicker(d time.Duration) Ticker

NewTicker is currently unimplemented, will panic. TODO: make interval clock use FakeClock so this can be implemented.

func (*IntervalClock) NewTimer Uses

func (*IntervalClock) NewTimer(d time.Duration) Timer

NewTimer is currently unimplemented, will panic. TODO: make interval clock use FakeClock so this can be implemented.

func (*IntervalClock) Now Uses

func (i *IntervalClock) Now() time.Time

Now returns i's time.

func (*IntervalClock) Since Uses

func (i *IntervalClock) Since(ts time.Time) time.Duration

Since returns time since the time in i.

func (*IntervalClock) Sleep Uses

func (*IntervalClock) Sleep(d time.Duration)

Sleep is currently unimplemented; will panic.

type PassiveClock Uses

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 Uses

type RealClock struct{}

RealClock really calls time.Now()

func (RealClock) After Uses

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

After is the same as time.After(d).

func (RealClock) NewTicker Uses

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

NewTicker returns a new Ticker.

func (RealClock) NewTimer Uses

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

NewTimer returns a new Timer.

func (RealClock) Now Uses

func (RealClock) Now() time.Time

Now returns the current time.

func (RealClock) Since Uses

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

Since returns time since the specified timestamp.

func (RealClock) Sleep Uses

func (RealClock) Sleep(d time.Duration)

Sleep pauses the RealClock for duration d.

type Ticker Uses

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

Ticker defines the Ticker interface

type Timer Uses

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.

Package clock imports 2 packages (graph) and is imported by 229 packages. Updated 2019-11-26. Refresh now. Tools for package owners.