cyclemanager

Documentation

Index

• type CycleFunc
• type CycleManager
  • func New(cycleTicker CycleTicker, cycleFunc CycleFunc) *CycleManager
  • func (c *CycleManager) Running() bool
  • func (c *CycleManager) Start()
  • func (c *CycleManager) Stop(ctx context.Context) (stopResult chan bool)
  • func (c *CycleManager) StopAndWait(ctx context.Context) error
• type CycleTicker
  • func CompactionCycleTicker() CycleTicker
  • func GeoCommitLoggerCycleTicker() CycleTicker
  • func HnswCommitLoggerCycleTicker() CycleTicker
  • func MemtableFlushCycleTicker() CycleTicker
  • func NewExpTicker(minInterval, maxInterval time.Duration, base, steps uint) CycleTicker
  • func NewFixedIntervalTicker(interval time.Duration) CycleTicker
  • func NewLinearTicker(minInterval, maxInterval time.Duration, steps uint) CycleTicker
  • func NewNoopTicker() CycleTicker
  • func NewSeriesTicker(intervals []time.Duration) CycleTicker
• type FixedIntervalTicker
  • func (t *FixedIntervalTicker) C() <-chan time.Time
  • func (t *FixedIntervalTicker) CycleExecuted(executed bool)
  • func (t *FixedIntervalTicker) Start()
  • func (t *FixedIntervalTicker) Stop()
• type NoopTicker
  • func (t *NoopTicker) C() <-chan time.Time
  • func (t *NoopTicker) CycleExecuted(executed bool)
  • func (t *NoopTicker) Start()
  • func (t *NoopTicker) Stop()
• type SeriesTicker
  • func (t *SeriesTicker) C() <-chan time.Time
  • func (t *SeriesTicker) CycleExecuted(executed bool)
  • func (t *SeriesTicker) Start()
  • func (t *SeriesTicker) Stop()
• type ShouldBreakFunc
• type TickerProvider
  • func ExpTickerProvider(minInterval, maxInterval time.Duration, base, steps uint) TickerProvider
  • func FixedIntervalTickerProvider(interval time.Duration) TickerProvider
  • func LinearTickerProvider(minInterval, maxInterval time.Duration, steps uint) TickerProvider
  • func SeriesTickerProvider(intervals []time.Duration) TickerProvider

Types

type CycleFunc

type CycleFunc func(shouldBreak ShouldBreakFunc) bool

return value indicates whether actual work was done in the cycle

type CycleManager

type CycleManager struct {
	sync.RWMutex
	// contains filtered or unexported fields
}

func New

func New(cycleTicker CycleTicker, cycleFunc CycleFunc) *CycleManager

func (*CycleManager) Running

func (c *CycleManager) Running() bool

func (*CycleManager) Start

func (c *CycleManager) Start()

Starts instance, does not block Does nothing if instance is already started

func (*CycleManager) Stop

func (c *CycleManager) Stop(ctx context.Context) (stopResult chan bool)

Stops running instance, does not block Returns channel with final stop result - true / false

If given context is cancelled before it is handled by stop logic, instance is not stopped If called multiple times, all contexts have to be cancelled to cancel stop (any valid will result in stopping instance) stopResult is the same (consistent) for multiple calls

func (*CycleManager) StopAndWait

func (c *CycleManager) StopAndWait(ctx context.Context) error

Stops running instance, waits for stop to occur or context to expire (which comes first) Returns error if instance was not stopped

type CycleTicker

type CycleTicker interface {
	Start()
	Stop()
	C() <-chan time.Time
	// called with bool value whenever cycle function finished execution
	// true - indicates cycle function actually did some processing
	// false - cycle function returned without doing anything
	CycleExecuted(executed bool)
}

func CompactionCycleTicker

func CompactionCycleTicker() CycleTicker

3s . 6.8s .. 14.4s .... 29.6s ........ 60s

func GeoCommitLoggerCycleTicker

func GeoCommitLoggerCycleTicker() CycleTicker

10s . 13.3s .. 20s .... 33.3s ........ 60s

func HnswCommitLoggerCycleTicker

func HnswCommitLoggerCycleTicker() CycleTicker

500ms . 806ms .. 1.42s .... 2.65s ........ 5.1s ................10s

func MemtableFlushCycleTicker

func MemtableFlushCycleTicker() CycleTicker

100ms . 258ms .. 574ms .... 1.206s ........ 2.471s ................ 5s

func NewExpTicker

func NewExpTicker(minInterval, maxInterval time.Duration, base, steps uint) CycleTicker

Creates ticker with intervals between minInterval and maxInterval values. Number of intervals in-between is determined by steps value. Ticker starts with minInterval value and with every report of executed "false" changes interval value to next one, up until maxInterval. Report of executed "true" resets interval to minInterval Example: for minInterval = 100ms, maxInterval = 5s, base = 2, steps = 4, intervals are 100ms . 427ms .. 1080ms .... 2387ms ........ 5000ms

If min- or maxInterval is <= 0 or base = 0 or steps = 0 or min > maxInterval, ticker will not fire

func NewFixedIntervalTicker

func NewFixedIntervalTicker(interval time.Duration) CycleTicker

Creates ticker with fixed interval. Interval is not changed regardless of execution results reported by cycle function

If interval <= 0 given, ticker will not fire

func NewLinearTicker

func NewLinearTicker(minInterval, maxInterval time.Duration, steps uint) CycleTicker

Creates ticker with intervals between minInterval and maxInterval values. Number of intervals in-between is determined by steps value. Ticker starts with minInterval value and with every report of executed "false" changes interval value to next one, up until maxInterval. Report of executed "true" resets interval to minInterval Example: for minInterval = 100ms, maxInterval = 5s, steps = 4, intervals are 100ms . 1325ms . 2550ms . 3775ms . 5000ms

If min- or maxInterval is <= 0 or steps = 0 or min > maxInterval, ticker will not fire

func NewNoopTicker

func NewNoopTicker() CycleTicker

func NewSeriesTicker

func NewSeriesTicker(intervals []time.Duration) CycleTicker

Creates ticker with set of interval values. Ticker starts with intervals[0] value and with every report of executed "false" changes interval value to next one in given array up until last one. Report of executed "true" resets interval to interval[0]

If any of intervals given is <= 0 given, ticker will not fire

type FixedIntervalTicker

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

func (*FixedIntervalTicker) C

func (t *FixedIntervalTicker) C() <-chan time.Time

func (*FixedIntervalTicker) CycleExecuted

func (t *FixedIntervalTicker) CycleExecuted(executed bool)

func (*FixedIntervalTicker) Start

func (t *FixedIntervalTicker) Start()

func (*FixedIntervalTicker) Stop

func (t *FixedIntervalTicker) Stop()

type NoopTicker

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

func (*NoopTicker) C

func (t *NoopTicker) C() <-chan time.Time

func (*NoopTicker) CycleExecuted

func (t *NoopTicker) CycleExecuted(executed bool)

func (*NoopTicker) Start

func (t *NoopTicker) Start()

func (*NoopTicker) Stop

func (t *NoopTicker) Stop()

type SeriesTicker

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

func (*SeriesTicker) C

func (t *SeriesTicker) C() <-chan time.Time

func (*SeriesTicker) CycleExecuted

func (t *SeriesTicker) CycleExecuted(executed bool)

func (*SeriesTicker) Start

func (t *SeriesTicker) Start()

func (*SeriesTicker) Stop

func (t *SeriesTicker) Stop()

type ShouldBreakFunc

type ShouldBreakFunc func() bool

indicates whether cyclemanager's stop was requested to allow safely break execution of CycleFunc and stop cyclemanager earlier

type TickerProvider

type TickerProvider func() CycleTicker

func ExpTickerProvider

func ExpTickerProvider(minInterval, maxInterval time.Duration, base, steps uint) TickerProvider

func FixedIntervalTickerProvider

func FixedIntervalTickerProvider(interval time.Duration) TickerProvider

func LinearTickerProvider

func LinearTickerProvider(minInterval, maxInterval time.Duration, steps uint) TickerProvider

func SeriesTickerProvider

func SeriesTickerProvider(intervals []time.Duration) TickerProvider