mirror

type Member struct {
	// Name identifies the member in the replica index; it must stay stable.
	Name string
	// Zone places the member, for example "aws-eu-west-1"; members in the
	// instance's zone are read and written first.
	Zone string
	// Store is the member's blob store.
	Store blob.Store
	// WriteEnabled lets the member receive new copies. A member with it
	// false is drained: it serves reads but gets nothing new.
	WriteEnabled bool
	// Kind names the member's backend (fs, s3, gcs, azure) for Status; the
	// mirror itself does not use it.
	Kind string
}

type MemberStatus struct {
	Name, Zone, Kind string
	WriteEnabled     bool
	// Available is false while the member's breaker is open: reads and
	// writes go to the other members first.
	Available bool
	// Latency is the weighted average of recent successful calls; zero
	// before the first one.
	Latency time.Duration
	// Replicas are the member's replica records per state, ordered by state.
	Replicas []store.ReplicaCount
	// SoleCopies counts the blobs whose only present copy is on this
	// member. A drained member (WriteEnabled false) is safe to remove from
	// the configuration once it is zero.
	SoleCopies int64
}

type Options struct {
	Members []Member
	// Redundancy is how many members keep each blob; zero means every
	// member (a full mirror).
	Redundancy int
	// WriteQuorum is how many members must store a blob before an upload
	// succeeds. Zero means Redundancy-1 (at least 1): by default an upload
	// still succeeds with one member down, which is the outage the mirror
	// exists to ride out, and the missing copy is repaired later.
	WriteQuorum int
	// Zone is this instance's zone.
	Zone string
	// MemberTimeout bounds how long members may finish after the quorum;
	// zero means DefaultMemberTimeout.
	MemberTimeout time.Duration
	// ChunkSize is the fan-out buffer. Zero derives it: the smallest
	// multiple of every member's part size (blob.PartSizer) that is at least
	// DefaultChunkSize, so the s3 and azure defaults (8 MiB) with the gcs
	// default (16 MiB) give 16 MiB. An explicit size must be a multiple of
	// every member's part size.
	ChunkSize int64
	// Sessions keeps the mirror's own upload sessions (the member upload
	// IDs). Members keep their own sessions.
	Sessions session.Store
	// Replicas records which members hold which blobs.
	Replicas store.ReplicaIndex
	// BreakerThreshold and BreakerCooldown tune each member's breaker; zero
	// means the defaults.
	BreakerThreshold int
	BreakerCooldown  time.Duration
	// Now supplies the time for the breaker, latency and replica records;
	// nil means time.Now.
	Now func() time.Time

	// The repair worker's settings (repair.go). Blobs and Leases are only
	// required by Repair: a mirror that never repairs may leave them nil.
	//
	// Blobs is the blob index whose reference counts tell a deferred delete
	// whether the blob was uploaded again since.
	Blobs store.BlobIndex
	// Leases holds the lease that keeps two repair passes from overlapping.
	Leases store.LeaseStore
	// RepairLease names the lease a pass holds; empty means
	// "blob-mirror-repair". Two mirrors sharing a lease store (the hot and
	// cold tiers) need different names, or each pass of one skips the other.
	RepairLease string
	// RepairBatch, RepairMaxAttempts and RepairBackoff tune a pass; zero
	// means the defaults.
	RepairBatch       int
	RepairMaxAttempts int
	RepairBackoff     time.Duration
	// OnRepair, when set, receives every pass RunRepair makes, so the server
	// can log or count them.
	OnRepair func(RepairReport, error)
}

type RemovedMember struct {
	Name string
	// Replicas are its replica records per state, ordered by state.
	Replicas []store.ReplicaCount
	// SoleCopies counts the blobs whose only present copy is on it.
	SoleCopies int64
}

type RepairReport struct {
	// Skipped is set when another pass held the lease; nothing was done.
	Skipped bool
	// Copied counts pending replicas filled by copying from another member.
	Copied int
	// Found counts pending replicas whose member already held the blob, for
	// example a commit that finished after its record was written.
	Found int
	// Failed counts attempts that failed this pass.
	Failed int
	// Deleted counts tombstones whose copy was removed.
	Deleted int
	// DeletesSkipped counts tombstones of blobs uploaded again since the
	// delete, which were kept rather than removed.
	DeletesSkipped int
	// Backfilled counts pending records added to bring a blob up to the
	// redundancy, for example on a newly added member.
	Backfilled int
	// Drained counts pending records added because a blob's only copies are
	// on members no longer accepting writes.
	Drained int
}

type Status struct {
	Redundancy  int
	WriteQuorum int
	// Zone is this instance's zone.
	Zone string
	// UnderReplicated counts blobs with fewer present copies than
	// Redundancy (store.ReplicaIndex.UnderReplicated).
	UnderReplicated int64
	Members         []MemberStatus
	// Removed are members with replica records that are no longer
	// configured. Repair neither copies to nor reads from them, so a blob
	// whose only present copy is on one (SoleCopies) is out of the mirror's
	// reach until the member is configured again.
	Removed []RemovedMember
}

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