func (r *RtRefreshManager) RefreshNoWait() {
	select {
	case r.triggerRefresh <- &triggerRefreshReq{}:
	default:
	}
}
RefreshNoWait requests the refresh manager to refresh the Routing Table.
However, it moves on without blocking if it's request can't get through.
package rtrefresh
import (
	"context"
	"fmt"
	"sync"
	"time"
	"github.com/libp2p/go-libp2p-core/host"
	"github.com/libp2p/go-libp2p-core/peer"
	kbucket "github.com/libp2p/go-libp2p-kbucket"
	"github.com/hashicorp/go-multierror"
	logging "github.com/ipfs/go-log"
	"github.com/multiformats/go-base32"
)
var logger = logging.Logger("dht/RtRefreshManager")
const (
	peerPingTimeout = 10 * time.Second
)
type triggerRefreshReq struct {
	respCh          chan error
	forceCplRefresh bool
}
type RtRefreshManager struct {
	ctx       context.Context
	cancel    context.CancelFunc
	refcount  sync.WaitGroup
	closeOnce sync.Once
	h         host.Host
	dhtPeerId peer.ID
	rt        *kbucket.RoutingTable
	enableAutoRefresh   bool                                         
	refreshKeyGenFnc    func(cpl uint) (string, error)               
	refreshQueryFnc     func(ctx context.Context, key string) error  
	refreshQueryTimeout time.Duration                                
	refreshInterval                    time.Duration
	successfulOutboundQueryGracePeriod time.Duration
	triggerRefresh chan *triggerRefreshReq  
	refreshDoneCh chan struct{}  
}
func NewRtRefreshManager(h host.Host, rt *kbucket.RoutingTable, autoRefresh bool,
	refreshKeyGenFnc func(cpl uint) (string, error),
	refreshQueryFnc func(ctx context.Context, key string) error,
	refreshQueryTimeout time.Duration,
	refreshInterval time.Duration,
	successfulOutboundQueryGracePeriod time.Duration,
	refreshDoneCh chan struct{}) (*RtRefreshManager, error) {
	ctx, cancel := context.WithCancel(context.Background())
	return &RtRefreshManager{
		ctx:       ctx,
		cancel:    cancel,
		h:         h,
		dhtPeerId: h.ID(),
		rt:        rt,
		enableAutoRefresh: autoRefresh,
		refreshKeyGenFnc:  refreshKeyGenFnc,
		refreshQueryFnc:   refreshQueryFnc,
		refreshQueryTimeout:                refreshQueryTimeout,
		refreshInterval:                    refreshInterval,
		successfulOutboundQueryGracePeriod: successfulOutboundQueryGracePeriod,
		triggerRefresh: make(chan *triggerRefreshReq),
		refreshDoneCh:  refreshDoneCh,
	}, nil
}
func (r *RtRefreshManager) Start() error {
	r.refcount.Add(1)
	go r.loop()
	return nil
}
func (r *RtRefreshManager) Close() error {
	r.closeOnce.Do(func() {
		r.cancel()
		r.refcount.Wait()
	})
	return nil
}
func (r *RtRefreshManager) Refresh(force bool) <-chan error {
	resp := make(chan error, 1)
	r.refcount.Add(1)
	go func() {
		defer r.refcount.Done()
		select {
		case r.triggerRefresh <- &triggerRefreshReq{respCh: resp, forceCplRefresh: force}:
		case <-r.ctx.Done():
			resp <- r.ctx.Err()
		}
	}()
	return resp
}