if err != nil && !errors.Is(err, context.DeadlineExceeded) && !errors.As(err, &timedout) {
		if len(dui.BucketsUsage) > 0 {
			internalLogOnceIf(GlobalContext, fmt.Errorf("unable to retrieve usage information for bucket: %s, relying on older value cached in-memory: err(%v)", bucket, err), "bucket-usage-cache-"+bucket)
		} else {

		if r.Flags.Filter.OlderThan > 0 && time.Since(info.ModTime) < r.Flags.Filter.OlderThan {
			// skip all objects that are newer than specified older duration
			return false
		}

		if r.Flags.Filter.NewerThan > 0 && time.Since(info.ModTime) >= r.Flags.Filter.NewerThan {
			// skip all objects that are older than specified newer duration
			return false
		}

		return false
	}

	if currentKernel == 0 {
		// We could not get any valid value return false
		return false
	}

	// legacy linux indicator for printing warnings
	// about older Linux kernels and Go runtime.
	return currentKernel < kernel.Version(4, 0, 0)
}

func setMaxResources(ctx *cli.Context) (err error) {
	// Set the Go runtime max threads threshold to 90% of kernel setting.

//   rules:
//     - type: object  # regular objects with zero or more older versions
//       name: NAME # match object names that satisfy the wildcard expression.
//       olderThan: 70h # match objects older than this value
//       createdBefore: "2006-01-02T15:04:05.00Z" # match objects created before "date"
//       tags:
//         - key: name

	xlHeader = [4]byte{'X', 'L', '2', ' '}

	// Current version being written.
	xlVersionCurrent [4]byte
)

const (
	// Breaking changes.
	// Newer versions cannot be read by older software.
	// This will prevent downgrades to incompatible versions.
	xlVersionMajor = 1

	// Non breaking changes.
	// Bumping this is informational, but should be done

	return client.restClient.IsOnline()
}

// Close - marks the client as closed.
func (client *peerRESTClient) Close() error {
	client.restClient.Close()
	return nil
}

// GetLocks - fetch older locks for a remote node.
func (client *peerRESTClient) GetLocks() (lockMap map[string][]lockRequesterInfo, err error) {
	resp, err := getLocksRPC.Call(context.Background(), client.gridConn(), grid.NewMSS())

// newer version is available.
func prepareUpdateMessage(downloadURL string, older time.Duration) string {
	if downloadURL == "" || older <= 0 {
		return ""
	}

	// Compute friendly duration string to indicate time
	// difference between newer and current release.
	t := time.Time{}
	newerThan := humanize.RelTime(t, t.Add(older), "before the latest release", "")

	if globalServerCtxt.JSON {

		{2 * 365 * 24 * time.Hour, "my_download_url", "2 years before the latest release"},
	}

	plainMsg := "You are running an older version of MinIO released"

	for i, testCase := range testCases {
		output := prepareUpdateMessage(testCase.dlURL, testCase.older)
		line1 := fmt.Sprintf("%s %s", plainMsg, color.YellowBold(testCase.expectedSubStr))
		line2 := fmt.Sprintf("Update: %s", color.CyanBold(testCase.dlURL))

)

// Legacy envs
const (
	legacyEnvAuditLoggerHTTPEndpoint = "MINIO_AUDIT_LOGGER_HTTP_ENDPOINT"
	legacyEnvLoggerHTTPEndpoint      = "MINIO_LOGGER_HTTP_ENDPOINT"
)

// SetLoggerHTTPAudit - helper for migrating older config to newer KV format.
func SetLoggerHTTPAudit(scfg config.Config, k string, args http.Config) {
	if !args.Enabled {
		// Do not enable audit targets, if not enabled
		return
	}

		name            string
		content         string
		meta            map[string]string
		addDeleteMarker bool
	}{
		{testBuckets[0], "unique/folder/", "", nil, true},
		{testBuckets[0], "unique/folder/1.txt", "content", nil, false},
		{testBuckets[1], "unique/folder/1.txt", "content", nil, true},
	}
	for _, object := range testObjects {
		md5Bytes := md5.Sum([]byte(object.content))