Skip to content

SeaweedFS is a distributed storage system for object storage (S3), file systems, Iceberg table buckets, and Lance vector buckets, designed to handle billions of files with O(1) disk access and effortless horizontal scaling.

4.9 KB
Raw Blame
package storage

import (
	"sort"
	"strconv"
	"strings"
	"time"
)

// VersionCounts is how many clusters ran one version per day, aligned to the
// shared date axis of the enclosing VersionSeries.
type VersionCounts struct {
	Version  string   `json:"version"`
	Clusters []uint64 `json:"clusters"`
}

// OtherVersions is the versions beyond the caller's limit, summed per day so a
// stacked chart still adds up to the cluster total.
type OtherVersions struct {
	Count    int      `json:"count"`
	Clusters []uint64 `json:"clusters"`
}

// VersionSeries is the version make-up of the fleet over time: one cluster
// count per version per day, oldest release first.
type VersionSeries struct {
	Dates         []string        `json:"dates"`
	Versions      []VersionCounts `json:"versions"`
	Other         *OtherVersions  `json:"other,omitempty"`
	TotalClusters uint64          `json:"total_clusters"` // across all versions on the last day
}

// GetVersionSeries returns the last `days` days of per-version cluster counts
// across confirmed clusters. Versions beyond `limit` are folded into Other,
// keeping the ones with the most clusters on the last day.
func (s *PrometheusStorage) GetVersionSeries(days, limit int) VersionSeries {
	s.mu.RLock()
	defer s.mu.RUnlock()

	histories := versionedHistories(s.seriesHistories())
	axis := newDailySeries(days, histories)
	activeSince := time.Now().UTC().AddDate(0, 0, -activeDays).Unix()
	last := len(axis.dates) - 1
	series := VersionSeries{Dates: axis.dates}

	daily := make(map[string][]uint64)
	for _, history := range histories {
		versions, ok := align(axis, history, activeSince, sampleVersion)
		if !ok {
			continue
		}
		for i, v := range versions {
			if v == "" {
				continue // before the cluster's first day in the window
			}
			counts, ok := daily[v]
			if !ok {
				counts = make([]uint64, len(axis.dates))
				daily[v] = counts
			}
			counts[i]++
		}
	}

	for v, counts := range daily {
		series.Versions = append(series.Versions, VersionCounts{Version: v, Clusters: counts})
		series.TotalClusters += counts[last]
	}
	// Ordered by release rather than by size: the caller stacks them, and a
	// stack whose order changes with the counts is unreadable over time.
	sort.Slice(series.Versions, func(i, j int) bool {
		return versionLess(series.Versions[i].Version, series.Versions[j].Version)
	})

	if limit > 0 && len(series.Versions) > limit {
		// Old releases are a long tail of one-cluster bands; keep the versions
		// most of the fleet is on now and sum the rest into one band.
		ranked := append([]VersionCounts(nil), series.Versions...)
		sort.Slice(ranked, func(i, j int) bool {
			if ranked[i].Clusters[last] != ranked[j].Clusters[last] {
				return ranked[i].Clusters[last] > ranked[j].Clusters[last]
			}
			return versionLess(ranked[j].Version, ranked[i].Version)
		})
		other := OtherVersions{Count: len(ranked) - limit, Clusters: make([]uint64, len(axis.dates))}
		for _, v := range ranked[limit:] {
			for i, c := range v.Clusters {
				other.Clusters[i] += c
			}
		}
		kept := make(map[string]bool, limit)
		for _, v := range ranked[:limit] {
			kept[v.Version] = true
		}
		versions := series.Versions[:0]
		for _, v := range series.Versions {
			if kept[v.Version] {
				versions = append(versions, v)
			}
		}
		series.Versions = versions
		series.Other = &other
	}
	return series
}

// versionedHistories drops the samples recorded before the reported version was
// kept in history, so the version series spans the days it actually knows a
// version for instead of climbing out of a run of blank days.
func versionedHistories(histories map[string][]HistorySample) map[string][]HistorySample {
	out := make(map[string][]HistorySample, len(histories))
	for id, history := range histories {
		var kept []HistorySample
		for _, sample := range history {
			if sample.Version != "" {
				kept = append(kept, sample)
			}
		}
		if len(kept) > 0 {
			out[id] = kept
		}
	}
	return out
}

// versionLess orders release strings like "3.97" and "4.40" by their numeric
// components rather than lexically, which would sort "10.02" before "9.99". A
// build suffix sits next to the release it was built from. Anything that
// doesn't parse, such as the "unknown" a client with no version compiled in
// reports, sorts first.
func versionLess(a, b string) bool {
	an, aSuffix, aok := versionParts(a)
	bn, bSuffix, bok := versionParts(b)
	if aok != bok {
		return !aok
	}
	if !aok {
		return a < b
	}
	for i := 0; i < len(an) && i < len(bn); i++ {
		if an[i] != bn[i] {
			return an[i] < bn[i]
		}
	}
	if len(an) != len(bn) {
		return len(an) < len(bn)
	}
	return aSuffix < bSuffix
}

func versionParts(v string) ([]int, string, bool) {
	number, suffix, _ := strings.Cut(v, "-")
	fields := strings.Split(number, ".")
	parts := make([]int, 0, len(fields))
	for _, field := range fields {
		n, err := strconv.Atoi(field)
		if err != nil {
			return nil, "", false
		}
		parts = append(parts, n)
	}
	return parts, suffix, len(parts) > 0
}