Probe simplification (#1784)

* Probe simplification

 - the main reason of rework is that previous implementation hung
   when calling Do() after Stop()

* replace atomics with mutex

* access Probe.interval under lock

plugin/pkg/up/up.go

@@ -10,49 +10,27 @@ import (
 // Probe is used to run a single Func until it returns true (indicating a target is healthy). If an Func
 // is already in progress no new one will be added, i.e. there is always a maximum of 1 checks in flight.
 type Probe struct {
-	do   chan Func
-	stop chan bool
-
-	target string
-
 	sync.Mutex
 	inprogress int
+	interval   time.Duration
 }
 
 // Func is used to determine if a target is alive. If so this function must return nil.
 type Func func() error
 
 // New returns a pointer to an intialized Probe.
-func New() *Probe {
+func New() *Probe { return &Probe{} }
-	return &Probe{stop: make(chan bool), do: make(chan Func)}
-}
 
 // Do will probe target, if a probe is already in progress this is a noop.
-func (p *Probe) Do(f Func) { p.do <- f }
+func (p *Probe) Do(f Func) {
-
-// Stop stops the probing.
-func (p *Probe) Stop() { p.stop <- true }
-
-// Start will start the probe manager, after which probes can be initialized with Do.
-func (p *Probe) Start(interval time.Duration) { go p.start(interval) }
-
-func (p *Probe) start(interval time.Duration) {
-	for {
-		select {
-		case <-p.stop:
 	p.Lock()
-			p.inprogress = stop
+	if p.inprogress != idle {
 		p.Unlock()
 		return
-		case f := <-p.do:
-			p.Lock()
-			if p.inprogress == active || p.inprogress == stop {
-				p.Unlock()
-				continue
 	}
 	p.inprogress = active
+	interval := p.interval
 	p.Unlock()
-
 	// Passed the lock. Now run f for as long it returns false. If a true is returned
 	// we return from the goroutine and we can accept another Func to run.
 	go func() {
@@ -74,7 +52,22 @@ func (p *Probe) start(interval time.Duration) {
 		p.Unlock()
 	}()
 }
+
+// Stop stops the probing.
+func (p *Probe) Stop() {
+	p.Lock()
+	p.inprogress = stop
+	p.Unlock()
 }
+
+// Start will initialize the probe manager, after which probes can be initiated with Do.
+func (p *Probe) Start(interval time.Duration) { p.SetInterval(interval) }
+
+// SetInterval sets the probing interval to be used by upcoming probes initiated with Do.
+func (p *Probe) SetInterval(interval time.Duration) {
+	p.Lock()
+	p.interval = interval
+	p.Unlock()
 }
 
 const (