// Copyright 2020 Kentaro Hibino. All rights reserved.
// Use of this source code is governed by a MIT license
// that can be found in the LICENSE file.

package asynq

import (
	
	

	
	
)

// healthchecker is responsible for pinging broker periodically
// and call user provided HeathCheckFunc with the ping result.
type healthchecker struct {
	logger *log.Logger
	broker base.Broker

	// channel to communicate back to the long running "healthchecker" goroutine.
	done chan struct{}

	// interval between healthchecks.
	interval time.Duration

	// function to call periodically.
	healthcheckFunc func(error)
}

type healthcheckerParams struct {
	logger          *log.Logger
	broker          base.Broker
	interval        time.Duration
	healthcheckFunc func(error)
}

func newHealthChecker( healthcheckerParams) *healthchecker {
	return &healthchecker{
		logger:          .logger,
		broker:          .broker,
		done:            make(chan struct{}),
		interval:        .interval,
		healthcheckFunc: .healthcheckFunc,
	}
}

func ( *healthchecker) () {
	if .healthcheckFunc == nil {
		return
	}

	.logger.Debug("Healthchecker shutting down...")
	// Signal the healthchecker goroutine to stop.
	.done <- struct{}{}
}

func ( *healthchecker) ( *sync.WaitGroup) {
	if .healthcheckFunc == nil {
		return
	}

	.Add(1)
	go func() {
		defer .Done()
		 := time.NewTimer(.interval)
		for {
			select {
			case <-.done:
				.logger.Debug("Healthchecker done")
				.Stop()
				return
			case <-.C:
				 := .broker.Ping()
				.healthcheckFunc()
				.Reset(.interval)
			}
		}
	}()
}