tendermint/blockchain/v2/routine.go

114 lines
2.4 KiB
Go
Raw Normal View History

2019-07-25 16:02:47 +02:00
package v2
import (
"fmt"
)
2019-07-30 12:17:51 +02:00
// TODO
// break out routines
// logging
// metrics
2019-07-29 08:45:59 +02:00
type handleFunc = func(event Event) Events
2019-07-27 10:58:58 +02:00
2019-07-29 08:45:59 +02:00
// Routine
type Routine struct {
name string
input chan Event
errors chan error
output chan Event
stopped chan struct{}
finished chan struct{}
handle handleFunc
2019-07-25 16:02:47 +02:00
}
2019-07-29 08:45:59 +02:00
func newRoutine(name string, output chan Event, handleFunc handleFunc) *Routine {
return &Routine{
name: name,
input: make(chan Event, 1),
errors: make(chan error, 1),
output: output,
stopped: make(chan struct{}, 1),
finished: make(chan struct{}, 1),
handle: handleFunc,
2019-07-27 10:58:58 +02:00
}
}
2019-07-31 08:10:47 +02:00
// TODO: refactor the handle to return an second variable, error which can signal
//to the run looop when the handler is done
2019-07-29 08:45:59 +02:00
func (rt *Routine) run() {
fmt.Printf("%s: run\n", rt.name)
2019-07-25 16:02:47 +02:00
for {
2019-07-29 12:40:59 +02:00
select {
case iEvent, ok := <-rt.input:
if !ok {
fmt.Printf("%s: stopping\n", rt.name)
rt.stopped <- struct{}{}
2019-07-29 12:47:43 +02:00
return
2019-07-29 12:40:59 +02:00
}
oEvents := rt.handle(iEvent)
2019-07-31 08:10:47 +02:00
// XXX: this should check for error and exit if error
2019-07-29 12:40:59 +02:00
fmt.Printf("%s handled %d events\n", rt.name, len(oEvents))
for _, event := range oEvents {
// check for finished
if _, ok := event.(routineFinished); ok {
fmt.Printf("%s: finished\n", rt.name)
rt.finished <- struct{}{}
return
}
fmt.Println("writting back to output")
2019-07-29 12:40:59 +02:00
rt.output <- event
}
case iEvent, ok := <-rt.errors:
if !ok {
fmt.Printf("%s: errors closed\n", rt.name)
continue
}
oEvents := rt.handle(iEvent)
fmt.Printf("%s handled %d events from errors\n", rt.name, len(oEvents))
for _, event := range oEvents {
rt.output <- event
}
2019-07-27 00:25:32 +02:00
}
2019-07-25 16:02:47 +02:00
}
}
func (rt *Routine) feedback() {
for event := range rt.output {
rt.send(event)
}
}
2019-07-25 16:02:47 +02:00
2019-07-29 08:45:59 +02:00
func (rt *Routine) send(event Event) bool {
fmt.Printf("%s: send\n", rt.name)
if err, ok := event.(error); ok {
2019-07-29 12:40:59 +02:00
select {
case rt.errors <- err:
return true
default:
fmt.Printf("%s: errors channel was full\n", rt.name)
return false
}
} else {
select {
case rt.input <- event:
return true
default:
fmt.Printf("%s: channel was full\n", rt.name)
return false
}
2019-07-27 00:25:32 +02:00
}
}
2019-07-29 08:45:59 +02:00
func (rt *Routine) stop() {
fmt.Printf("%s: stop\n", rt.name)
2019-07-29 12:40:59 +02:00
close(rt.errors)
2019-07-29 08:45:59 +02:00
close(rt.input)
<-rt.stopped
}
// XXX: this should probably produced the finished
// channel and let the caller deicde how long to wait
func (rt *Routine) wait() {
<-rt.finished
}