// cycle back return 'true'
		return true
	}

	ctx = lkctx.Context()
	defer locker.Unlock(lkctx)

	// Perform callhome once and then keep running it at regular intervals.
	performCallhome(ctx)

	callhomeTimer := time.NewTimer(globalCallhomeConfig.FrequencyDur())
	defer callhomeTimer.Stop()

	for {
		if !globalCallhomeConfig.Enabled() {
			// Stop the processing as callhome got disabled

	var wg sync.WaitGroup
	for i := range numGoroutines {
		wg.Add(1)
		go func(id int) {
			defer wg.Done()
			for j := 0; j < opsPerGoroutine; j++ {
				stats.Inc("TestAPI")
			}
		}(i)
	}

	for i := range numGoroutines / 2 {
		wg.Add(1)
		go func(id int) {
			defer wg.Done()
			for range opsPerGoroutine / 2 {
				_ = stats.Load(false)
			}
		}(i)
	}
	wg.Wait()

		time.Sleep(time.Duration(d))
	}

	l.mutex.Lock()
	defer l.mutex.Unlock()
	reply = !l.lockNotFound
	return reply, nil
}

func (l *lockServer) ForceUnlock(args *LockArgs) (reply bool, err error) {
	if d := atomic.LoadInt64(&l.responseDelay); d != 0 {
		time.Sleep(time.Duration(d))
	}

	l.mutex.Lock()
	defer l.mutex.Unlock()
	if len(args.UID) != 0 {

	return func(endpoint Endpoint, err error, once bool) {
		reqInfo := (&logger.ReqInfo{}).AppendTags("endpoint", endpoint.String())
		ctx := logger.SetReqInfo(GlobalContext, reqInfo)
		mutex.Lock()
		defer mutex.Unlock()

		m, ok := printOnce[endpoint]
		if !ok {
			m = make(map[string]int)
			printOnce[endpoint] = m
			if once {
				m[err.Error()]++
				peersLogAlwaysIf(ctx, err)
				return
			}
		}

	cache := store.rlock()
	defer store.runlock()

	u, ok := cache.iamUsersMap[user]
	if !ok {
		// Check the sts map
		u, ok = cache.iamSTSAccountsMap[user]
	}
	return u, ok
}

// GetMappedPolicy - fetches mapped policy from memory.
func (store *IAMStoreSys) GetMappedPolicy(name string, isGroup bool) (MappedPolicy, bool) {
	cache := store.rlock()
	defer store.runlock()

	if isGroup {

	ctx, cancel := context.WithCancel(context.Background())

	dm.m.Lock()
	dm.cancelRefresh = cancel
	dm.m.Unlock()

	go func() {
		defer cancel()

		refreshTimer := time.NewTimer(dm.refreshInterval)
		defer refreshTimer.Stop()

		for {
			select {
			case <-ctx.Done():
				return
			case <-refreshTimer.C:
				noQuorum, err := refreshLock(ctx, dm.clnt, id, source, quorum)

	}

	loopCount := 100
	var wg sync.WaitGroup
	var unexpectedError bool
	writerFinish := make(chan struct{})

	wg.Add(1)
	go func(id uint) {
		defer wg.Done()
		defer close(writerFinish)

		for j := 0; j < loopCount; j++ {
			var tmp User
			err := tx.Session(&gorm.Session{}).First(&tmp, id).Error
			if err == nil || isUsingClosedConnError(err) {
				continue
			}

	}
}

// Test printing server common message.
func TestPrintServerCommonMessage(t *testing.T) {
	ctx, cancel := context.WithCancel(t.Context())
	defer cancel()

	obj, fsDir, err := prepareFS(ctx)
	if err != nil {
		t.Fatal(err)
	}
	defer os.RemoveAll(fsDir)
	if err = newTestConfig(globalMinioDefaultRegion, obj); err != nil {
		t.Fatal(err)
	}

	apiEndpoints := []string{"http://127.0.0.1:9000"}

	go func() {
		// Add jitter to the update time so multiple sets don't sync up.
		updateTime := 30*time.Second + time.Duration(float64(10*time.Second)*rand.Float64())
		t := time.NewTicker(updateTime)
		defer t.Stop()
		defer saverWg.Done()
		var lastSave time.Time

		for {
			select {
			case <-t.C:
				if cache.Info.LastUpdate.Equal(lastSave) {
					continue
				}

	currentMinute    serviceRTTMinuteStats
}

func (h *metrics) setConnSuccess(reqStartTime time.Time) {
	h.Lock()
	defer h.Unlock()
	h.LastCheckSuccess = reqStartTime
}

func (h *metrics) setConnFailure(reqStartTime time.Time) {
	h.Lock()
	defer h.Unlock()
	h.LastCheckFailure = reqStartTime
}

func (h *metrics) updateLastFullMinute(currReqMinute time.Time) {