storagecap

type BucketView struct {
	Bucket   string     `json:"bucket"`
	Purpose  string     `json:"purpose"`
	Bytes    int64      `json:"bytes"`
	Objects  int64      `json:"objects"`
	ListedAt *time.Time `json:"listed_at"`
}

type ClusterCapacity struct {
	Total int64 `json:"total_bytes"`
	Used  int64 `json:"used_bytes"`
	Free  int64 `json:"free_bytes"`
	// Servers is how many volume servers answered; Unreached lists the ones
	// that did not, so a partial reading is labeled as one.
	Servers   int      `json:"servers"`
	Unreached []string `json:"unreached"`
}

type ClusterView struct {
	MasterURL string          `json:"master_url"`
	Capacity  ClusterCapacity `json:"capacity"`
	Error     string          `json:"error,omitempty"`
}

type DatabaseView struct {
	Bytes      int64       `json:"bytes"`
	LimitBytes *int64      `json:"limit_bytes"`
	Tables     []TableView `json:"tables"`
}

type Deps struct {
	DB       *sql.DB
	Settings SettingsStore
	// Spools reads every receiver's spool state; nil without webhooks.
	Spools func(ctx context.Context) ([]whstore.SpoolState, error)
	// HTTP reads the SeaweedFS cluster.
	HTTP *http.Client
	// EnvBudgets are the budgets MCP_PLATFORM_STORAGE_BUDGETS names, which
	// a budget in the settings overrides bucket by bucket.
	EnvBudgets map[string]int64
	// OnSeaweedFS reports whether a bucket is on the SeaweedFS cluster: such
	// a bucket with no budget can grow into the cluster's free space, which
	// is then its free space. Nil names none.
	OnSeaweedFS func(ctx context.Context, bucket string) bool
	// Buckets are the buckets the configuration writes to, asked about
	// beside those the usage rows name, so a bucket nothing was written to
	// yet is still detected.
	Buckets []string
	// Engine routes the alerts; nil records nothing and sends nothing.
	Engine *levelalert.Engine
	// PageURL is the admin storage page an alert links to; empty omits it.
	PageURL  string
	Interval time.Duration
	Now      func() time.Time
}

type Forecast struct {
	// Rate7d and Rate30d are the growth in bytes per day fitted over the last
	// 7 and 30 days, nil where the history is too short.
	Rate7d  *float64 `json:"rate_7d_bytes_per_day"`
	Rate30d *float64 `json:"rate_30d_bytes_per_day"`
	// HistoryHours is how much history the store has, first sample to last,
	// and Rate7dMinHistoryHours and Rate30dMinHistoryHours how much each rate
	// needs, so a reader says how far a missing rate is from being measured.
	HistoryHours           float64 `json:"history_hours"`
	Rate7dMinHistoryHours  float64 `json:"rate_7d_min_history_hours"`
	Rate30dMinHistoryHours float64 `json:"rate_30d_min_history_hours"`
	// RateUsed names the rate the projection uses, "7d" or "30d": the slower
	// of the two that are growing, so a burst does not bring the date in.
	RateUsed string `json:"rate_used,omitempty"`
	// DaysLeft and ExhaustionAt are when the store fills at RateUsed, nil
	// when it is not growing or has no known capacity.
	DaysLeft     *float64   `json:"days_left"`
	ExhaustionAt *time.Time `json:"exhaustion_at"`
}

type Input struct {
	Channels           *[]string              `json:"channels,omitempty"`
	DatabaseLimitBytes *int64                 `json:"database_limit_bytes,omitempty"`
	Budgets            *map[string]int64      `json:"budgets,omitempty"`
	SeaweedFS          *SeaweedFS             `json:"seaweedfs,omitempty"`
	HistoryDays        *int                   `json:"history_days,omitempty"`
	UsedPercent        *levelalert.Thresholds `json:"used_percent,omitempty"`
	DaysLeft           *levelalert.Thresholds `json:"days_left,omitempty"`
}

type Point struct {
	At    time.Time `json:"at"`
	Used  int64     `json:"used_bytes"`
	Total *int64    `json:"total_bytes"`
}

type ReconcileView struct {
	Purpose      string    `json:"purpose"`
	Orphaned     int64     `json:"orphaned"`
	Dangling     int64     `json:"dangling"`
	ReconciledAt time.Time `json:"reconciled_at"`
}

type Report struct {
	GeneratedAt time.Time       `json:"generated_at"`
	HistoryDays int             `json:"history_days"`
	Stores      []StoreView     `json:"stores"`
	Database    DatabaseView    `json:"database"`
	Buckets     []BucketView    `json:"buckets"`
	Reconciles  []ReconcileView `json:"reconciles"`
	LastScan    *ScanView       `json:"last_scan"`
	SeaweedFS   *ClusterView    `json:"seaweedfs"`
	// SeaweedFSBuckets are the buckets whose endpoint answers as SeaweedFS:
	// the settings offer the cluster's address only where one does.
	SeaweedFSBuckets []string    `json:"seaweedfs_buckets"`
	Spools           []SpoolView `json:"spools"`
}

type ScanView struct {
	DurationSeconds float64   `json:"duration_seconds"`
	Objects         int64     `json:"objects"`
	FinishedAt      time.Time `json:"finished_at"`
}

type SeaweedFS struct {
	// MasterURL is the master's HTTP address, e.g. http://seaweedfs-master:9333.
	MasterURL string `json:"master_url"`
	// VolumeURLs, when set, are the volume servers read instead of the ones
	// the master lists: a master inside a cluster lists addresses the
	// platform may not reach.
	VolumeURLs []string `json:"volume_urls"`
}

type Service struct {
	// contains filtered or unexported fields
}

type Settings struct {
	Channels []string `json:"channels"`
	// DatabaseLimitBytes is the size the database may reach: its volume, or
	// the plan's quota. The platform cannot read the database server's disk,
	// so it is the operator's. Zero is unknown.
	DatabaseLimitBytes int64 `json:"database_limit_bytes"`
	// Budgets is the byte budget per bucket, for a store the platform cannot
	// read capacity from (cloud S3). It overrides MCP_PLATFORM_STORAGE_BUDGETS
	// for every bucket it names.
	Budgets     map[string]int64      `json:"budgets"`
	SeaweedFS   SeaweedFS             `json:"seaweedfs"`
	HistoryDays int                   `json:"history_days"`
	UsedPercent levelalert.Thresholds `json:"used_percent"`
	DaysLeft    levelalert.Thresholds `json:"days_left"`
}

type SettingsStore interface {
	Get(ctx context.Context) (settingsjson.Stored[Settings], error)
	Set(ctx context.Context, v Settings, author string) error
}

type SpoolView struct {
	Replica   string    `json:"replica"`
	Dir       string    `json:"dir"`
	Bytes     int64     `json:"bytes"`
	MaxBytes  int64     `json:"max_bytes"`
	FsTotal   *int64    `json:"fs_total_bytes"`
	FsFree    *int64    `json:"fs_free_bytes"`
	Reporting bool      `json:"reporting"`
	UpdatedAt time.Time `json:"updated_at"`
}

type StoreView struct {
	// Store is the key its history is kept under: database, seaweedfs,
	// bucket:<name>, spool:<replica>.
	Store string `json:"store"`
	Kind  string `json:"kind"`
	Name  string `json:"name"`
	// UsedBytes is what the store holds. TotalBytes is its capacity, nil
	// where the platform knows none: a database with no limit set, a bucket
	// with no budget.
	UsedBytes  int64  `json:"used_bytes"`
	TotalBytes *int64 `json:"total_bytes"`
	// CapacityFrom names where a bucket's capacity comes from: "budget", or
	// "seaweedfs" for a bucket on the cluster with no budget, whose capacity
	// is what it holds plus the cluster's free space. Empty for the rest.
	CapacityFrom string   `json:"capacity_from,omitempty"`
	FreeBytes    *int64   `json:"free_bytes"`
	PercentUsed  *float64 `json:"percent_used"`
	Forecast
	// Level is the worse of the store's two alert levels under the current
	// thresholds, empty when neither is crossed.
	Level string `json:"level,omitempty"`
}

type TableView struct {
	Name  string `json:"name"`
	Index bool   `json:"index"`
	Bytes int64  `json:"bytes"`
	Rows  int64  `json:"rows"`
}

type View struct {
	Settings
	UpdatedBy string `json:"updated_by,omitempty"`
	UpdatedAt string `json:"updated_at,omitempty"`
}