adminhandler

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

type BucketSchemeStore interface {
	// SchemeOverride returns the bucket's explicit scheme override, empty when
	// the bucket follows the cluster default. It returns ErrBucketNotFound when
	// the bucket does not exist.
	SchemeOverride(ctx context.Context, bucket string) (string, error)
	// SetScheme sets the bucket's override, or clears it when scheme is empty.
	// It returns ErrBucketNotFound when the bucket does not exist and
	// ErrSchemeRejected when the scheme is invalid or the topology cannot host
	// it.
	SetScheme(ctx context.Context, bucket, scheme string) error
}

type BucketUsage struct {
	Bucket  string
	Objects int64
	Bytes   int64
	// Updated is when an incremental change last moved the counters.
	Updated time.Time
	// Counted is when a full recount last anchored them; zero when none has.
	Counted time.Time
}

type BucketUsageSource interface {
	// BucketUsage returns every accounted bucket, sorted by name.
	BucketUsage(ctx context.Context) ([]BucketUsage, error)
}

type BuildInfo struct {
	Version string
	Commit  string
}

type ClusterDisk struct {
	ID         string
	Weight     float64
	TotalBytes uint64
	FreeBytes  uint64
}

type ClusterNode struct {
	ID    string
	Addr  string
	Rack  string
	Disks []ClusterDisk
	// Live is the node's live runtime state, fetched from the node itself; nil
	// when it did not report.
	Live *NodeLive
	// LiveError says why Live is nil (unreachable, or a binary that does not
	// serve live state).
	LiveError string
}

type ClusterStatus struct {
	SchemaVersion       int
	BinarySchemaVersion int
	Nodes               []ClusterNode
	// RebalanceRunning reports whether a runner holds the cluster-wide
	// election; the cursor is the in-progress/last resume point.
	RebalanceRunning              bool
	RebalanceCursorBucket, Cursor string
}

type ClusterStatusSource interface {
	ClusterStatus(ctx context.Context) (ClusterStatus, error)
}

type CredentialManager interface {
	// List returns every credential, secrets omitted, sorted by access key.
	List() []auth.KeyInfo
	// Create adds a credential, generating the access key and/or secret when
	// CreateInput leaves them empty, and returns the secret exactly once.
	Create(in auth.CreateInput) (*auth.Created, error)
	// Delete removes a credential by access key.
	Delete(accessKey string) error
}

type DiskWeight struct {
	Node   string
	Disk   string
	Weight float64
	Reason string
}

type DiskWeightStore interface {
	ListDiskWeights(ctx context.Context) ([]DiskWeight, error)
	SetDiskWeight(ctx context.Context, node, disk string, weight float64, reason string) error
	ClearDiskWeight(ctx context.Context, node, disk string) error
}

type Migration struct {
	Version     int
	Description string
}

type MigrationControl interface {
	// Status reads the cluster's schema version and computes what is pending.
	Status(ctx context.Context) (MigrationStatus, error)
	// Apply runs every pending migration under the cluster-wide election and
	// returns the resulting status. Returns ErrMigrationConflict when an apply
	// is already running or the cluster schema is newer than this binary.
	Apply(ctx context.Context) (MigrationStatus, error)
}

type MigrationStatus struct {
	// ClusterVersion is the version recorded in etcd; 0 when none is recorded
	// yet (no node has joined).
	ClusterVersion int
	// BinaryVersion is the schema version this binary implements.
	BinaryVersion int
	// Pending are the migrations between the two, in order.
	Pending []Migration
	// Running reports an apply in flight on this process.
	Running bool
	// LastApplied and LastErr describe the most recent apply on this process.
	LastApplied []int
	LastErr     string
}

type NodeDisk struct {
	ID      string
	HasData bool
	// Err is why the disk could not be probed. A disk that failed to answer is
	// unknown, never drained.
	Err string
	// Fragments and Bytes are what the node's occupancy index says the disk
	// holds, so a drain in progress has a number attached. Meaningful only
	// when Counted; HasData remains what decides "empty".
	Fragments int64
	Bytes     int64
	Counted   bool
}

type NodeLive struct {
	Version       string
	SchemaVersion int
	UptimeSeconds float64
	// RepairQueueDepth is the node's pending async remainder/repair backlog.
	RepairQueueDepth int
	// Rebalance* is the node's rebalance runner and its current/last run.
	RebalanceState                                        RebalanceState
	RebalanceObjects, RebalanceRelocated, RebalanceFailed int
	RebalanceErr                                          string
	// Scrub* and the repair totals are cumulative since the node started.
	ScrubPasses, ScrubObjects, ScrubRepaired, ScrubFailed int64
	RebuiltFragments, SweptStale                          int64
	CorruptReplicas, Converted                            int64
	// ECUnverified reports that the node's last scrub pass saw an EC set
	// failing parity verification.
	ECUnverified bool
	// Disks is what each of the node's disks holds, as only the node can know.
	Disks []NodeDisk
}

type Options struct {
	// Manager is the access-key store to manage. Optional: nil disables the
	// access-key endpoints (they return 501) — e.g. a headless cluster admin
	// with file-backed credentials, which live on the data nodes.
	Manager CredentialManager
	// Build is reported by GetInfo.
	Build BuildInfo
	// AuthEnabled reports whether the S3 server enforces SigV4.
	AuthEnabled bool
	// StartTime is the process start, for uptime. Defaults to now.
	StartTime time.Time
	// Rebalance drives the cluster rebalance runner; nil outside cluster mode
	// (the endpoints then report "disabled" / refuse control).
	Rebalance RebalanceControl
	// ClusterStatus assembles the cluster-wide status; nil outside cluster mode
	// (the endpoint then reports "disabled").
	ClusterStatus ClusterStatusSource
	// Migrations reports and applies cluster schema migrations; nil outside
	// cluster mode (the endpoint then reports "disabled" and refuses to apply).
	Migrations MigrationControl
	// Reloader applies hot-reloadable configuration on demand (POST
	// /api/v1/reload); nil on a listener with nothing to reload (the headless
	// cluster admin), where the endpoint returns 501.
	Reloader Reloader
	// ConfigRevision returns the config revision currently in effect, reported
	// by GetInfo; nil reports none.
	ConfigRevision func() string
	// BucketSchemes reads and writes per-bucket replication-scheme overrides
	// via the control plane; nil outside cluster mode (the scheme endpoints
	// then return 501).
	BucketSchemes BucketSchemeStore
	// DiskWeights reads and writes per-disk placement weight overrides — how a
	// disk is drained without editing a config file and restarting its node
	// (fs SPEC §11.6). nil outside cluster mode (the endpoints return 501).
	DiskWeights DiskWeightStore
	// BucketUsage reads the durable per-bucket object accounting; nil outside
	// cluster mode (the endpoint then returns 501), where the index lives in
	// the control plane.
	BucketUsage BucketUsageSource
	// PublicRead reads and writes the cluster-wide public-read bucket list; nil
	// unless the server uses cluster-wide credentials (the public-read endpoints
	// then return 501).
	PublicRead PublicReadStore
	// ClusterDefaultScheme is the scheme applied to buckets without an override,
	// echoed by the scheme endpoints. Empty when unknown.
	ClusterDefaultScheme string
	// contains filtered or unexported fields
}

type PublicReadStore interface {
	// PublicReadBuckets returns the current public-read bucket list.
	PublicReadBuckets(ctx context.Context) ([]string, error)
	// SetPublicReadBuckets replaces the list. It returns ErrPublicReadRejected
	// when a bucket name is invalid.
	SetPublicReadBuckets(ctx context.Context, buckets []string) error
}

type RebalanceControl interface {
	// Start launches the rebalance (campaigning for the cluster-wide slot).
	// Returns ErrRebalanceConflict when one is already waiting or running.
	Start(ctx context.Context) error
	// Pause stops this node's runner, keeping the resume cursor. Returns
	// ErrRebalanceConflict when nothing is waiting or running.
	Pause(ctx context.Context) error
	// Resume relaunches a paused rebalance from the persisted cursor. Returns
	// ErrRebalanceConflict unless the runner is paused.
	Resume(ctx context.Context) error
	// Status snapshots the runner.
	Status(ctx context.Context) RebalanceStatus
}

type RebalanceState string

type RebalanceStatus struct {
	State RebalanceState
	// Objects, Relocated and Failed are the current or last run's progress.
	Objects, Relocated, Failed int
	// CursorBucket/CursorKey is the persisted resume cursor (empty when none).
	CursorBucket, CursorKey string
	// StartedAt/FinishedAt frame the current or last run; zero when unset.
	StartedAt, FinishedAt time.Time
	// Err is why the last run failed.
	Err string
	// RepairQueueDepth is the node's pending async remainder backlog.
	RepairQueueDepth int
}

type ReloadResult struct {
	// Reloaded names the hot-reloadable parts the reload applied, any of
	// "credentials", "tls".
	Reloaded []string
	// ConfigRevision is the config file's revision marker after the reload;
	// empty when the config sets none.
	ConfigRevision string
}

type Reloader interface {
	// Reload re-reads the config file and applies the hot-reloadable parts,
	// returning what it changed and the config revision now in effect.
	Reload(ctx context.Context) (ReloadResult, error)
}