Fix kubernetes providers shutdown and clean safe.Pool

pkg/safe/routine.go

@@ -10,88 +10,37 @@ import (
 	"github.com/containous/traefik/v2/pkg/log"
 )
 
-type routine struct {
-	goroutine func(chan bool)
-	stop      chan bool
-}
-
 type routineCtx func(ctx context.Context)
 
 // Pool is a pool of go routines
 type Pool struct {
-	routines   []routine
-	waitGroup  sync.WaitGroup
-	lock       sync.Mutex
-	baseCtx    context.Context
-	baseCancel context.CancelFunc
-	ctx        context.Context
-	cancel     context.CancelFunc
+	waitGroup sync.WaitGroup
+	ctx       context.Context
+	cancel    context.CancelFunc
 }
 
 // NewPool creates a Pool
 func NewPool(parentCtx context.Context) *Pool {
-	baseCtx, baseCancel := context.WithCancel(parentCtx)
-	ctx, cancel := context.WithCancel(baseCtx)
+	ctx, cancel := context.WithCancel(parentCtx)
 	return &Pool{
-		baseCtx:    baseCtx,
-		baseCancel: baseCancel,
-		ctx:        ctx,
-		cancel:     cancel,
+		ctx:    ctx,
+		cancel: cancel,
 	}
 }
 
-// Ctx returns main context
-func (p *Pool) Ctx() context.Context {
-	return p.baseCtx
-}
-
 // GoCtx starts a recoverable goroutine with a context
 func (p *Pool) GoCtx(goroutine routineCtx) {
-	p.lock.Lock()
 	p.waitGroup.Add(1)
 	Go(func() {
 		defer p.waitGroup.Done()
 		goroutine(p.ctx)
 	})
-	p.lock.Unlock()
-}
-
-// Go starts a recoverable goroutine, and can be stopped with stop chan
-func (p *Pool) Go(goroutine func(stop chan bool)) {
-	p.lock.Lock()
-	newRoutine := routine{
-		goroutine: goroutine,
-		stop:      make(chan bool, 1),
-	}
-	p.routines = append(p.routines, newRoutine)
-	p.waitGroup.Add(1)
-	Go(func() {
-		defer p.waitGroup.Done()
-		goroutine(newRoutine.stop)
-	})
-	p.lock.Unlock()
 }
 
 // Stop stops all started routines, waiting for their termination
 func (p *Pool) Stop() {
-	p.lock.Lock()
-	defer p.lock.Unlock()
 	p.cancel()
-	for _, routine := range p.routines {
-		routine.stop <- true
-	}
 	p.waitGroup.Wait()
-	for _, routine := range p.routines {
-		close(routine.stop)
-	}
-}
-
-// Cleanup releases resources used by the pool, and should be called when the pool will no longer be used
-func (p *Pool) Cleanup() {
-	p.Stop()
-	p.lock.Lock()
-	defer p.lock.Unlock()
-	p.baseCancel()
 }
 
 // Go starts a recoverable goroutine