}
	}
}

// TestHTTPStatsRaceCondition tests the race condition fix for HTTPStats.
// This test specifically addresses the race between:
// - Write operations via updateStats.
// - Read operations via toServerHTTPStats(false).
func TestRaulStatsRaceCondition(t *testing.T) {
	httpStats := newHTTPStats()
	// Simulate the concurrent scenario from the original race condition:

	serverStats.TotalS3Canceled = ServerHTTPAPIStats{
		APIStats: st.totalS3Canceled.Load(toLowerKeys),
	}
	return serverStats
}

// Update statistics from http request and response data
func (st *HTTPStats) updateStats(api string, w *xhttp.ResponseRecorder) {
	st.totalS3Requests.Inc(api)

	// Increment the prometheus http request response histogram with appropriate label

	if lrTime.Sub(currentReleaseTime) <= 0 {
		updateStatus.Results = append(updateStatus.Results, madmin.ServerPeerUpdateStatus{
			Host:           local,
			Err:            fmt.Sprintf("server is running the latest version: %s", Version),
			CurrentVersion: Version,
		})

		for _, client := range globalNotificationSys.peerClients {
			updateStatus.Results = append(updateStatus.Results, madmin.ServerPeerUpdateStatus{

                entry.updateState(Smb2LeaseState.SMB2_LEASE_NONE);
            }
            releaseLease(key);
        } catch (Exception e) {
            log.error("Error handling lease break for key: " + key, e);
            // On error, ensure we're in safe state
            LeaseEntry entry = leases.get(key);
            if (entry != null) {
                entry.updateState(Smb2LeaseState.SMB2_LEASE_NONE);

    }

    /**
     * Updates the git repository's tags from the specified remote
     * @param remote the remote to use to update
     */
    public void updateTags(String remote) {
        runCommand("git", "fetch", "--tags", Objects.requireNonNull(remote));
    }

    /**
     * Fetch all tags matching the specified pattern, returning them as {@link QualifiedVersion} instances.

	}
	err = conn.SetWriteDeadline(time.Now().Add(connWriteTimeout))
	if err != nil {
		return err
	}
	return wsutil.WriteMessage(conn, c.side, ws.OpBinary, dst)
}

func (c *Connection) connect() {
	c.updateState(StateConnecting)
	rng := rand.New(rand.NewSource(time.Now().UnixNano()))
	// Runs until the server is shut down.
	for {
		if c.State() == StateShutdown {
			return
		}
		dialStarted := time.Now()

            logger.error("Failed to purge user info.", e);
            resultBuf.append(e.getMessage()).append("\n");
        }

        // update job logs
        try {
            jobLogService.updateStatus();
        } catch (final Exception e) {
            logger.error("Failed to purge job logs.", e);
            resultBuf.append(e.getMessage()).append("\n");
        }

        return resultBuf.toString();

    /**
     * Updates the status of expired jobs that haven't finished.
     * Jobs that have been running longer than the expired job interval
     * without an end time are marked as failed.
     */
    public void updateStatus() {
        final long expiry = ComponentUtil.getSystemHelper().getCurrentTimeAsLong() - expiredJobInterval;
        final List<JobLog> list = jobLogBhv.selectList(cb -> {

				wg.Wait()
				sm.Unlock()
			}
			sTimer.Reset(siteResyncSaveInterval)
		case <-ctx.Done():
			return
		}
	}
}

// update overall site resync state
func (sm *siteResyncMetrics) updateState(s SiteResyncStatus) error {
	if !globalSiteReplicationSys.isEnabled() {
		return nil
	}
	sm.Lock()
	defer sm.Unlock()
	switch s.Status {
	case ResyncStarted:

        // Now update the remote, and make sure we update the tags too
        gitWrapper.updateRemote(upstream);

        LOGGER.info("Updating tags from [{}]", upstream);
        gitWrapper.updateTags(upstream);
    }

    /**
     * This methods checks the supplied version and answers {@code false} if the fetching of git
     * tags can be skipped, or {@code true} otherwise.
     * <p>