driver

type Chance struct {
	Flag   string
	Plain  float64
	Locked float64
	Usage  string
	At     func(*Chances) *float64
}

type Chances struct {
	Broken, Fail, Stuck, Cross, Down, Up float64
}

type Clock interface {
	Now() time.Time
	Sleep(time.Duration)
}

type Config struct {
	Every time.Duration // between ticks
	Batch int           // a merge step's batch
	// TakeLimit is the work cards a member takes in its one take of a tick;
	// 0 is the member's width, as the view shows it, else DefaultWidth.
	TakeLimit int
	// ReadLimit is the read cards a reader begins, and reports, in its one
	// call of each a tick; 0 is its whole queue. Every batch is cut at Most.
	ReadLimit int
	Ticks     int // stop after this many ticks; 0 is until every stream lands
	// Hold plays the facts' downs as the coordinator's hold (fleet down and
	// fleet up); without it a member the facts take down falls silent (its
	// machine stops beating), takes no work while it is down, and comes back
	// by beating again and taking work again.
	Hold bool
	// Silent is members silent for a while: each stops beating From after
	// the driver starts, for For.
	Silent []Silence
}

type Driver struct {
	Run    func(args []string, stdout, stderr io.Writer) int
	Base   []string
	Facts  Facts
	Clock  Clock
	Out    io.Writer
	Config Config
	// Header is a line Loop prints once, before its first tick, when it has
	// read that it may play; a Loop that refuses to play prints nothing.
	Header string
	// contains filtered or unexported fields
}

type Facts interface {
	// Work is how a worker's work card came back.
	Work(card string) (ok bool, report string)
	// Read is what a reader found in a read card.
	Read(card string) (ok bool, finding string)
	// Merge is how a stream's batch went on its branch. others reads, when
	// called, the cards queued in the other streams' merge queues, which a
	// card may need first: a source calls it only for a cross-stream fact,
	// and it reads them then, after every merge step before this one.
	Merge(stream string, batch []string, others func() []string) Outcome
	// Up is which members are up this tick, given which are up now: a member
	// up may go down, and a member down may come up, each with its own chance.
	Up(tick int, members []string, up map[string]bool) map[string]bool
}

type Outcome struct {
	Conflict string // a card that did not merge
	Cross    string // <card>=<other>: a card needs a card of another stream first
	Red      bool
	Suspects []string // on red, the cards the branch's failure points at
}

type Seeded struct {
	Fail, Broken, Stuck, Cross, Red float64
	Down, Back                      float64
	// contains filtered or unexported fields
}

type Silence struct {
	Member    string
	From, For time.Duration
}