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 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
}

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 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
	// 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
	// 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)
}