idleshut/idleshut.go

// Package idleshut provides a lifecycle and idletime management tool.
package idleshut

import (
	"sync"
	"time"
)

// Config contains the options for creating a new process.
type Config struct {

	// Start, if non-nil, is called by Process.Start. If an error is returned,
	// starting the process is aborted.
	Start func() error

	// Stop, if non-nil, is called by Process.Stop. If an error is returned,
	// stopping the process is aborted.
	Stop func() error

	// If TickDuration is non-zero, the process will count ticks where
	// the process is active or idle. Process are kept active by the user
	// calling the Process.Touch() method. When the process has been idle for
	// more than MaxIdleTicks, it will be stopped. If ticking is enabled,
	// TickError must be set or operations will result in a panic.
	TickDuration time.Duration
	TickError    func(error)

	// Tick is called by Process for every iteration of Tick. If
	// an error is returned, it is sent to TickError. Additionally,
	// IdleTick and ActiveTick are called for idle and active ticks
	// respectively.
	Tick       func() error
	IdleTick   func() error
	ActiveTick func() error

	// MaxIdleTicks, if nonzero and ticking is configured, will cause
	// the process to stop once the maximum number of ticks has been
	// reached.
	MaxIdleTicks uint
}

func (cfg Config) validate() {
	allSet := cfg.TickError == nil && cfg.TickDuration == 0
	noneSet := cfg.TickError != nil && cfg.TickDuration != 0

	if !allSet && !noneSet {
		panic("idleshut: Config.IdleTick, config.IdleProcessError, and config.Tick must all be set or all be unset")
	}
}

// New returns a new Process with the given configuration.
func New(cfg Config) *Process {

	cfg.validate()
	return &Process{cfg: cfg}
}

// Process is a lifecycle and idle process monitor.
type Process struct {
	cfg Config

	mtx               sync.Mutex
	started           time.Time
	stopped           time.Time
	running           bool
	touched           bool
	idleTicks         uint
	currentGeneration uint
}

// Touch resets the idle timer to zero.
func (p *Process) Touch() bool {
	p.mtx.Lock()
	defer p.mtx.Unlock()

	p.idleTicks = 0
	p.touched = true

	return p.running
}

// Start initiates the process.
func (p *Process) Start() error {
	p.mtx.Lock()
	defer p.mtx.Unlock()

	if !p.running {
		var err error
		if p.cfg.Start != nil {
			err = p.cfg.Start()
		}
		if err != nil {
			return err
		}
		p.running = true
		p.started = time.Now()
		p.currentGeneration++
		go p.startTicker()
	}

	return nil
}

// Running returns true if the process is currently running.
func (p *Process) Running() bool {
	p.mtx.Lock()
	defer p.mtx.Unlock()

	return p.running
}

func (p *Process) generation() uint {
	p.mtx.Lock()
	defer p.mtx.Unlock()
	return p.currentGeneration
}

func (p *Process) startTicker() {
	if p.cfg.TickDuration == 0 {
		return
	}

	startingGen := p.generation()

	tk := time.NewTicker(p.cfg.TickDuration)
	for {
		<-tk.C
		// if we stopped running, or we started again and thus the geneneration has advanced, return
		if !p.Running() || p.generation() != startingGen {
			return
		}

		func() {
			p.mtx.Lock()
			defer p.mtx.Unlock()
			if p.cfg.Tick != nil {
				p.idleProcessError(p.cfg.Tick())
			}

			if p.touched {
				p.idleTicks = 0
				p.touched = false //reset
				if p.cfg.ActiveTick != nil {
					p.idleProcessError(p.cfg.ActiveTick())
				}
			} else {
				p.idleTicks++
				if p.cfg.IdleTick != nil {
					p.idleProcessError(p.cfg.IdleTick())
				}
				if p.idleTicks >= p.cfg.MaxIdleTicks {
					p.idleProcessError(p.stopWithLock())
				}
			}
		}()
	}
}

func (p *Process) idleProcessError(err error) {
	if err != nil && p.cfg.TickError != nil {
		go p.cfg.TickError(err)
	}
}

// Stop halts the process.
func (p *Process) Stop() error {
	p.mtx.Lock()
	defer p.mtx.Unlock()

	if p.running {
		return p.stopWithLock()
	}

	return nil
}

func (p *Process) stopWithLock() error {
	var err error
	if p.cfg.Stop != nil {
		err = p.cfg.Stop()
	}
	if err != nil {
		return err
	}
	p.idleTicks = 0
	p.running = false
	p.stopped = time.Now()

	return nil
}