You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
200 lines
4.9 KiB
200 lines
4.9 KiB
package v2
|
|
|
|
import (
|
|
"fmt"
|
|
"sync/atomic"
|
|
|
|
"github.com/tendermint/tendermint/libs/log"
|
|
)
|
|
|
|
// TODO
|
|
// * revisit panic conditions
|
|
// * audit log levels
|
|
// * Convert routine to an interface with concrete implmentation
|
|
|
|
type handleFunc = func(event Event) (Events, error)
|
|
|
|
// Routines are a structure which model a finite state machine as serialized
|
|
// stream of events processed by a handle function. This Routine structure
|
|
// handles the concurrency and messaging guarantees. Events are sent via
|
|
// `trySend` are handled by the `handle` function to produce an iterator
|
|
// `next()`. Calling `close()` on a routine will conclude processing of all
|
|
// sent events and produce `last()` event representing the terminal state.
|
|
type Routine struct {
|
|
name string
|
|
input chan Event
|
|
errors chan error
|
|
out chan Event
|
|
stopped chan struct{}
|
|
rdy chan struct{}
|
|
fin chan error
|
|
running *uint32
|
|
handle handleFunc
|
|
logger log.Logger
|
|
metrics *Metrics
|
|
stopping *uint32
|
|
}
|
|
|
|
func newRoutine(name string, handleFunc handleFunc) *Routine {
|
|
return &Routine{
|
|
name: name,
|
|
input: make(chan Event, 1),
|
|
handle: handleFunc,
|
|
errors: make(chan error, 1),
|
|
out: make(chan Event, 1),
|
|
stopped: make(chan struct{}, 1),
|
|
rdy: make(chan struct{}, 1),
|
|
fin: make(chan error, 1),
|
|
running: new(uint32),
|
|
stopping: new(uint32),
|
|
logger: log.NewNopLogger(),
|
|
metrics: NopMetrics(),
|
|
}
|
|
}
|
|
|
|
func (rt *Routine) setLogger(logger log.Logger) {
|
|
rt.logger = logger
|
|
}
|
|
|
|
// nolint:unused
|
|
func (rt *Routine) setMetrics(metrics *Metrics) {
|
|
rt.metrics = metrics
|
|
}
|
|
|
|
func (rt *Routine) start() {
|
|
rt.logger.Info(fmt.Sprintf("%s: run\n", rt.name))
|
|
starting := atomic.CompareAndSwapUint32(rt.running, uint32(0), uint32(1))
|
|
if !starting {
|
|
panic("Routine has already started")
|
|
}
|
|
close(rt.rdy)
|
|
errorsDrained := false
|
|
for {
|
|
if !rt.isRunning() {
|
|
rt.logger.Info(fmt.Sprintf("%s: breaking because not running\n", rt.name))
|
|
break
|
|
}
|
|
select {
|
|
case iEvent, ok := <-rt.input:
|
|
rt.metrics.EventsIn.With("routine", rt.name).Add(1)
|
|
if !ok {
|
|
if !errorsDrained {
|
|
rt.logger.Info(fmt.Sprintf("%s: waiting for errors to drain\n", rt.name))
|
|
|
|
continue // wait for errors to be drainned
|
|
}
|
|
rt.logger.Info(fmt.Sprintf("%s: stopping\n", rt.name))
|
|
close(rt.stopped)
|
|
rt.terminate(fmt.Errorf("stopped"))
|
|
return
|
|
}
|
|
oEvents, err := rt.handle(iEvent)
|
|
rt.metrics.EventsHandled.With("routine", rt.name).Add(1)
|
|
if err != nil {
|
|
rt.terminate(err)
|
|
return
|
|
}
|
|
rt.metrics.EventsOut.With("routine", rt.name).Add(float64(len(oEvents)))
|
|
rt.logger.Info(fmt.Sprintf("%s handled %d events\n", rt.name, len(oEvents)))
|
|
for _, event := range oEvents {
|
|
rt.logger.Info(fmt.Sprintln("writing back to output"))
|
|
rt.out <- event
|
|
}
|
|
case iEvent, ok := <-rt.errors:
|
|
rt.metrics.ErrorsIn.With("routine", rt.name).Add(1)
|
|
if !ok {
|
|
rt.logger.Info(fmt.Sprintf("%s: errors closed\n", rt.name))
|
|
errorsDrained = true
|
|
continue
|
|
}
|
|
oEvents, err := rt.handle(iEvent)
|
|
rt.metrics.ErrorsHandled.With("routine", rt.name).Add(1)
|
|
if err != nil {
|
|
rt.terminate(err)
|
|
return
|
|
}
|
|
rt.metrics.ErrorsOut.With("routine", rt.name).Add(float64(len(oEvents)))
|
|
for _, event := range oEvents {
|
|
rt.out <- event
|
|
}
|
|
}
|
|
}
|
|
}
|
|
func (rt *Routine) feedback() {
|
|
for event := range rt.out {
|
|
rt.trySend(event)
|
|
}
|
|
}
|
|
|
|
func (rt *Routine) trySend(event Event) bool {
|
|
if !rt.isRunning() || rt.isStopping() {
|
|
return false
|
|
}
|
|
|
|
rt.logger.Info(fmt.Sprintf("%s: sending %+v", rt.name, event))
|
|
if err, ok := event.(error); ok {
|
|
select {
|
|
case rt.errors <- err:
|
|
rt.metrics.ErrorsSent.With("routine", rt.name).Add(1)
|
|
return true
|
|
default:
|
|
rt.metrics.ErrorsShed.With("routine", rt.name).Add(1)
|
|
rt.logger.Info(fmt.Sprintf("%s: errors channel was full\n", rt.name))
|
|
return false
|
|
}
|
|
} else {
|
|
select {
|
|
case rt.input <- event:
|
|
rt.metrics.EventsSent.With("routine", rt.name).Add(1)
|
|
return true
|
|
default:
|
|
rt.metrics.EventsShed.With("routine", rt.name).Add(1)
|
|
rt.logger.Info(fmt.Sprintf("%s: channel was full\n", rt.name))
|
|
return false
|
|
}
|
|
}
|
|
}
|
|
|
|
func (rt *Routine) isRunning() bool {
|
|
return atomic.LoadUint32(rt.running) == 1
|
|
}
|
|
|
|
func (rt *Routine) isStopping() bool {
|
|
return atomic.LoadUint32(rt.stopping) == 1
|
|
}
|
|
|
|
func (rt *Routine) ready() chan struct{} {
|
|
return rt.rdy
|
|
}
|
|
|
|
func (rt *Routine) next() chan Event {
|
|
return rt.out
|
|
}
|
|
|
|
func (rt *Routine) stop() {
|
|
if !rt.isRunning() {
|
|
return
|
|
}
|
|
|
|
rt.logger.Info(fmt.Sprintf("%s: stop\n", rt.name))
|
|
stopping := atomic.CompareAndSwapUint32(rt.stopping, uint32(0), uint32(1))
|
|
if !stopping {
|
|
panic("Routine has already stopped")
|
|
}
|
|
|
|
close(rt.input)
|
|
close(rt.errors)
|
|
<-rt.stopped
|
|
}
|
|
|
|
func (rt *Routine) final() chan error {
|
|
return rt.fin
|
|
}
|
|
|
|
func (rt *Routine) terminate(reason error) {
|
|
stopped := atomic.CompareAndSwapUint32(rt.running, uint32(1), uint32(0))
|
|
if !stopped {
|
|
panic("called stop but already stopped")
|
|
}
|
|
rt.fin <- reason
|
|
}
|