curator

type Config struct {
	CuratorSeed       int64 // Seed for the random number generator.
	MaxReplFactor     int   // What is the max replication factor of a blob?
	MaxTractsToExtend int   // At most how many tracts can one extend a blob by at a time?

	MasterSpec string // How to find masters.

	Addr               string // Address for RPCs.
	UseFailure         bool   // Whether to enable the failure service.
	RejectReqThreshold int    // Pending client request limit.

	PartitionMonInterval time.Duration // At what interval do we check partitions?
	MinFreeBlobSlot      uint64        // Ask for a new partition when the number of free blob slots in existing partitions drops below this threshold.
	FreeMemLimit         uint64        // No new partition if free system memory drops below this.

	ConsistencyCheckInterval  time.Duration // How often to do a consistency check
	ConsistencyCheckBatchSize int           // How many blobs to checksum at once

	RaftACSpec string // Spec for raft autoconfig.

	// --- Master ---
	MasterHeartbeatInterval time.Duration

	// --- GC ---
	MetadataGCInterval   time.Duration
	MetadataUndeleteTime time.Duration

	// --- Tract Server Monitor ---
	// TODO(PL-1107)
	// Unhealthy is anything that hasn't beaten recently but hasn't been offline
	// long enough to be re-replicated.  Unhealthy servers won't host new data as
	// we expect writes to them to fail.
	//
	// NOTE: Needs to be related to tractserver/server.go:curatorHeartbeatInterval.
	// The idea is that if we miss a few heartbeats we'll re-replicate data to
	// unblock clients.
	TsUnhealthy time.Duration
	// Down is anything that hasn't beaten in so long that it is probably offline
	// for and the data on it should be considered gone.
	TsDown time.Duration
	// When a curator becomes a new leader tract servers might take some time to
	// know it. A newly elected curator leader will not claim any tract servers
	// unhealthy or down during the grace period.
	TsHeartbeatGracePeriod time.Duration

	// --- Tract Server ---
	// The interval of sending tracts to tract servers for finding missing tracts.
	SyncInterval time.Duration

	// --- Erasure Coding ---
	// Time after last write that a blob can be considered for erasure coding.
	WriteDelay time.Duration
}

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

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

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

type DyConfig struct {

	// How much bandwidth we can use for RS encoding.
	RSEncodeBandwidthGbps float32

	// How much bandwidth can we use for recovery (all types).
	RecoveryBandwidthGbps float32

	// Number of curator groups in this cluster.
	CuratorGroups int
}

type FailureDomainService interface {
	// FailureDomain retrieves the failure domain hierarchy for 'hosts'. The
	// returned failure domains for each host are organized from the lowest
	// level (host) to the highest (e.g., datacenter). The number of
	// levels should be the same across all hosts. Nil is returned if no
	// information is available.
	//
	// Use our current naming convention for example,
	//   hosts := []string{"bbaa01", "bbaa02", "ggaa23"}
	// can be mapped to the following result,
	//   {
	//     {"bbaa01", "bbaa", "bb"}, // {host, rack, cluster}
	//     {"bbaa02", "bbaa", "bb"},
	//     {"ggaa23", "ggaa", "gg"},
	//   }
	GetFailureDomain(hosts []string) [][]string
}

type MasterConnection interface {
	// RegisterCurator sends a request to the master to register this curator.
	RegisterCurator() (core.RegisterCuratorReply, core.Error)

	// CuratorHeartbeat sends a heartbeat to the master.
	CuratorHeartbeat(core.CuratorID) (core.CuratorHeartbeatReply, core.Error)

	// NewPartition sends a request for a new partition to the master.
	NewPartition(core.CuratorID) (core.NewPartitionReply, core.Error)
}

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

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

type RackBasedFailureDomain struct {
}

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

type StatusData struct {
	JobName       string
	Cfg           Config
	ID            core.CuratorID
	LeaderAddr    string
	Members       []string
	RaftTerm      uint64
	NumPartitions int
	FreeMem       uint64
	TotalMem      uint64
	FreeSpace     uint64
	Tractservers  []tractserverData

	Reboot       time.Time
	CtlRPC       map[string]string
	SrvRPC       map[string]string
	CuratorStats map[string]interface{}
	Now          time.Time
}

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

type TractserverTalker interface {
	// SetVersion asks the tractserver (tsid, addr) to set the version of 'id' to newVersion.
	// This will only succeed if the version at the tractserver is newVersion or newVersion-1.
	SetVersion(addr string, tsid core.TractserverID, id core.TractID, newVersion int, conditionalStamp uint64) core.Error

	// PullTract asks the tractserver at 'addr' with id 'tsid' to pull the tract with id 'id' and
	// version 'version' from the source hosts 'from', each of which should own a copy of the tract.
	PullTract(addr string, tsid core.TractserverID, from []string, id core.TractID, version int) core.Error

	// CheckTracts asks the tractserver at 'addr' with id 'tsid' if it has the tracts 'tracts'.
	CheckTracts(addr string, tsid core.TractserverID, tracts []core.TractState) core.Error

	// GCTract tells the tractserver at 'addr' that the tracts in 'old' are obsolete and the blob that
	// has the tracts in 'gone' has been deleted.
	//
	// Any host may delete the tracts in 'old' (or any older version thereof).
	// The tracts in 'gone' are safe to be deleted from any host as the blobs are permanently gone.
	//
	// Returns any error encountered when trying to talk to the tractserver.
	GCTract(addr string, tsid core.TractserverID, old []core.TractState, gone []core.TractID) core.Error

	// CtlStatTract is like the client StatTract, but bypasses request limits.
	CtlStatTract(addr string, tsid core.TractserverID, id core.TractID, version int) core.StatTractReply

	// PackTracts asks the tractserver to create a chunk with a bunch of tracts in it.
	// It will pull data from other tractservers and write it to the local disk.
	PackTracts(addr string, tsid core.TractserverID, length int, tracts []*core.PackTractSpec, id core.RSChunkID) core.Error

	// RSEncode asks the tractserver to pull N chunks from other tractservers, compute M
	// parity chunks, and write the parity chunks to other tractservers.
	RSEncode(addr string, tsid core.TractserverID, id core.RSChunkID, length int, srcs, dests []core.TSAddr, indexMap []int) core.Error
}