}
        });

        MockletHttpServletRequest request = getMockRequest();
        request.setAttribute(FessConfig.VIRTUAL_HOST_VALUE, "cached_value");

        String key = virtualHostHelper.getVirtualHostKey();
        assertEquals("cached_value", key);
    }

    public void test_processVirtualHost() {
        ComponentUtil.setFessConfig(new FessConfig.SimpleImpl() {

	memoryMetrics       *cachevalue.Cache[madmin.MemInfo]
	cpuMetrics          *cachevalue.Cache[madmin.CPUMetrics]
	clusterDriveMetrics *cachevalue.Cache[storageMetrics]
	nodesUpDown         *cachevalue.Cache[nodesOnline]
}

func newMetricsCache() *metricsCache {
	return &metricsCache{
		dataUsageInfo:       newDataUsageInfoCache(),
		esetHealthResult:    newESetHealthResultCache(),
		driveMetrics:        newDriveMetricsCache(),

package cmd

import (
	"context"
	"errors"
	"strings"
	"time"

	jsoniter "github.com/json-iterator/go"
	"github.com/minio/minio/internal/cachevalue"
)

const (
	dataUsageRoot   = SlashSeparator
	dataUsageBucket = minioMetaBucket + SlashSeparator + bucketMetaPrefix

	dataUsageObjName       = ".usage.json"

    return CollectSpliterators.map(entrySet().spliterator(), Entry::getKey);
  }

  private transient @Nullable ImmutableCollection<V> cachedValues = null;

  @Override
  public ImmutableCollection<V> values() {
    if (cachedValues != null) {
      return cachedValues;
    }
    return cachedValues = createValues();
  }

  // cached so that this.multimapView().inverse() only computes inverse once

    Object cachedKey = new Object();
    Object cachedValue = new Object();
    Cache<Object, Object> cache =
        new AbstractCache<Object, Object>() {
          @Override
          public @Nullable Object getIfPresent(Object key) {
            return cachedKey.equals(key) ? cachedValue : null;
          }
        };

    assertEquals(
        ImmutableMap.of(cachedKey, cachedValue),

			if err != nil {
				return
			}
			sizeS.totalSize = s.Size()
			sizeS.versions++
			return sizeS, nil
		}
		return
	}
	xls := xlStorage{drivePath: base, diskInfoCache: cachevalue.New[DiskInfo]()}
	xls.diskInfoCache.InitOnce(time.Second, cachevalue.Opts{}, func(ctx context.Context) (DiskInfo, error) {
		return DiskInfo{Total: 1 << 40, Free: 1 << 40}, nil
	})
	weSleep := func() bool { return false }

func NewBucketQuotaSys() *BucketQuotaSys {
	return &BucketQuotaSys{}
}

var bucketStorageCache = cachevalue.New[DataUsageInfo]()

// Init initialize bucket quota.
func (sys *BucketQuotaSys) Init(objAPI ObjectLayer) {
	bucketStorageCache.InitOnce(10*time.Second,
		cachevalue.Opts{ReturnLastGood: true, NoWait: true},
		func(ctx context.Context) (DataUsageInfo, error) {
			if objAPI == nil {

	"io"
	"net/http"
	"net/url"
	"path"
	"strconv"
	"strings"
	"sync/atomic"
	"time"

	"github.com/minio/madmin-go/v3"
	"github.com/minio/minio/internal/bpool"
	"github.com/minio/minio/internal/cachevalue"
	"github.com/minio/minio/internal/grid"
	xhttp "github.com/minio/minio/internal/http"
	xioutil "github.com/minio/minio/internal/ioutil"
	"github.com/minio/minio/internal/rest"
	xnet "github.com/minio/pkg/v3/net"

	storage      *xlStorage
	health       *diskHealthTracker
	healthCheck  bool

	metricsCache *cachevalue.Cache[DiskMetrics]
	diskCtx      context.Context
	diskCancel   context.CancelFunc
}

func (p *xlStorageDiskIDCheck) getMetrics() DiskMetrics {
	p.metricsCache.InitOnce(5*time.Second,
		cachevalue.Opts{},
		func(ctx context.Context) (DiskMetrics, error) {
			diskMetric := DiskMetrics{

	"github.com/klauspost/filepathx"
	"github.com/minio/madmin-go/v3"
	"github.com/minio/minio/internal/bucket/lifecycle"
	"github.com/minio/minio/internal/bucket/replication"
	"github.com/minio/minio/internal/cachevalue"
	"github.com/minio/minio/internal/config/storageclass"

	"github.com/minio/minio/internal/disk"
	xioutil "github.com/minio/minio/internal/ioutil"
	"github.com/minio/minio/internal/logger"
	"github.com/pkg/xattr"
)