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,71 +10,64 @@ 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) {
+	p.Lock()
+	if p.inprogress != idle {
+		p.Unlock()
+		return
+	}
+	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() {
+		for {
+			if err := f(); err == nil {
+				break
+			}
+			time.Sleep(interval)
+			p.Lock()
+			if p.inprogress == stop {
+				p.Unlock()
+				return
+			}
+			p.Unlock()
+		}
+
+		p.Lock()
+		p.inprogress = idle
+		p.Unlock()
+	}()
+}
 
 // Stop stops the probing.
-func (p *Probe) Stop() { p.stop <- true }
+func (p *Probe) Stop() {
+	p.Lock()
+	p.inprogress = stop
+	p.Unlock()
+}
 
-// Start will start the probe manager, after which probes can be initialized with Do.
+// Start will initialize the probe manager, after which probes can be initiated with Do.
-func (p *Probe) Start(interval time.Duration) { go p.start(interval) }
+func (p *Probe) Start(interval time.Duration) { p.SetInterval(interval) }
 
-func (p *Probe) start(interval time.Duration) {
+// SetInterval sets the probing interval to be used by upcoming probes initiated with Do.
-	for {
+func (p *Probe) SetInterval(interval time.Duration) {
-		select {
+	p.Lock()
-		case <-p.stop:
+	p.interval = interval
-			p.Lock()
+	p.Unlock()
-			p.inprogress = stop
-			p.Unlock()
-			return
-		case f := <-p.do:
-			p.Lock()
-			if p.inprogress == active || p.inprogress == stop {
-				p.Unlock()
-				continue
-			}
-			p.inprogress = active
-			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() {
-				for {
-					if err := f(); err == nil {
-						break
-					}
-					time.Sleep(interval)
-					p.Lock()
-					if p.inprogress == stop {
-						p.Unlock()
-						return
-					}
-					p.Unlock()
-				}
-
-				p.Lock()
-				p.inprogress = idle
-				p.Unlock()
-			}()
-		}
-	}
 }
 
 const (