}
	var (
		latestID, latestPeerName string
		lastUpdate               time.Time
		latestPeers              map[string]madmin.PeerInfo
	)

	for dID, ps := range info.PeerStates {
		if lastUpdate.IsZero() {
			lastUpdate = ps.UpdatedAt
			latestID = dID
			latestPeers = ps.Peers
		}
		if ps.UpdatedAt.After(lastUpdate) {
			lastUpdate = ps.UpdatedAt
			latestID = dID
			latestPeers = ps.Peers

							Entry:  update,
						}:
						}
					}
				}(cache.Info.Name)
				// Calc usage
				before := cache.Info.LastUpdate
				var err error
				cache, err = disk.NSScanner(ctx, cache, updates, healScanMode, nil)
				if err != nil {
					if !cache.Info.LastUpdate.IsZero() && cache.Info.LastUpdate.After(before) {
						scannerLogIf(ctx, cache.save(ctx, er, cacheName))
					} else {
						scannerLogIf(ctx, err)
					}

	if !ok {
		return nil
	}
	rs, ok := sm.resyncStatus[rst.resyncID]
	if !ok {
		return nil
	}
	m := madmin.SiteResyncMetrics{
		CollectedAt:     rs.LastUpdate,
		StartTime:       rs.StartTime,
		LastUpdate:      rs.LastUpdate,
		ResyncStatus:    rs.Status.String(),
		ResyncID:        rst.resyncID,
		DeplID:          rs.DeplID,
		ReplicatedSize:  rs.ReplicatedSize,
		ReplicatedCount: rs.ReplicatedCount,

	if err != nil {
		metricsLogIf(ctx, err)
		return nil
	}

	// data usage has not been captured yet.
	if dataUsageInfo.LastUpdate.IsZero() {
		return nil
	}

	m.Set(usageSinceLastUpdateSeconds, float64(time.Since(dataUsageInfo.LastUpdate)))

	for bucket, usage := range dataUsageInfo.BucketsUsage {
		quota, err := globalBucketQuotaSys.Get(ctx, bucket)
		if err != nil {

	TotalUsedCapacity uint64 `json:"usedCapacity,omitempty"`
	TotalFreeCapacity uint64 `json:"freeCapacity,omitempty"`

	// LastUpdate is the timestamp of when the data usage info was last updated.
	// This does not indicate a full scan.
	LastUpdate time.Time `json:"lastUpdate"`

	// Objects total count across all buckets
	ObjectsTotalCount uint64 `json:"objectsCount"`

	// Versions total count across all buckets

	var got dataUsageCache
	err = got.deserialize(&buf)
	if err != nil {
		t.Fatal(err)
	}
	if got.Info.LastUpdate.IsZero() {
		t.Error("lastupdate not set")
	}

	if !want.Info.LastUpdate.Equal(got.Info.LastUpdate) {
		t.Fatalf("deserialize LastUpdate mismatch\nwant: %+v\ngot:  %+v", want, got)
	}
	if len(want.Cache) != len(got.Cache) {

			}
		case "cl":
			z.CmdLine, err = dc.ReadString()
			if err != nil {
				err = msgp.WrapError(err, "CmdLine")
				return
			}
		case "lu":
			z.LastUpdate, err = dc.ReadTime()
			if err != nil {
				err = msgp.WrapError(err, "LastUpdate")
				return
			}
		case "dec":
			if dc.IsNil() {
				err = dc.ReadNil()
				if err != nil {
					err = msgp.WrapError(err, "Decommission")
					return

		PoolIndex:         h.PoolIndex,
		SetIndex:          h.SetIndex,
		DiskIndex:         h.DiskIndex,
		Finished:          h.Finished,
		Path:              h.Path,
		Started:           h.Started.UTC(),
		LastUpdate:        h.LastUpdate.UTC(),
		ObjectsTotalCount: h.ObjectsTotalCount,
		ObjectsTotalSize:  h.ObjectsTotalSize,
		ItemsHealed:       h.ItemsHealed,
		ItemsSkipped:      h.ItemsSkipped,
		ItemsFailed:       h.ItemsFailed,

// The updates are conditional so multiple callers can update with different states.
func (m *metacache) update(update metacache) {
	now := UTCNow()
	m.lastUpdate = now

	if update.lastHandout.After(m.lastHandout) {
		m.lastHandout = update.lastUpdate
		if m.lastHandout.After(now) {
			m.lastHandout = now
		}
	}
	if m.status == scanStateStarted && update.status == scanStateSuccess {
		m.ended = now
	}

				return
			}
		case "lh":
			z.lastHandout, err = dc.ReadTime()
			if err != nil {
				err = msgp.WrapError(err, "lastHandout")
				return
			}
		case "u":
			z.lastUpdate, err = dc.ReadTime()
			if err != nil {
				err = msgp.WrapError(err, "lastUpdate")
				return
			}
		case "b":
			z.bucket, err = dc.ReadString()
			if err != nil {
				err = msgp.WrapError(err, "bucket")
				return
			}
		case "flt":