core

type AckExtendBlobReply struct {
	// Number of tracts after extending the blob.
	NumTracts int

	Err Error
}

type AckExtendBlobReq struct {
	// The ID of the blob the client wants to extend.
	Blob BlobID

	// Successfully created tracts.
	Tracts []TractInfo
}

type BlobID uint64

type BlobInfo struct {
	// What is the replication factor of this blob? (REPLICATED storage class only)
	Repl int

	// How many tracts make up the blob?
	NumTracts int

	// When was the blob last written/read?
	MTime, ATime time.Time

	// How is this blob stored?
	Class StorageClass

	// How did the client hint that this should be stored?
	Hint StorageHint

	// Time after which this blob can be automatically deleted by the system.
	Expires time.Time
}

type BlobKey uint32

type CheckTractsReply struct {
	// NoError if everything went OK, otherwise an error representing what
	// went wrong.
	Err Error
}

type CheckTractsReq struct {
	// The tractserver that the curator expects it's talking to.
	TSID TractserverID

	// What tracts must the tractserver host?
	Tracts []TractState
}

type CreateBlobReply struct {
	// Was there an error?  If so, it's here.
	Err Error

	// The ID of the blob.
	ID BlobID
}

type CreateBlobReq struct {
	// The required replication factor for the blob we're creating.
	Repl int

	// The initial storage hint for the blob.
	Hint StorageHint

	// Expiry time.
	Expires time.Time
}

type CreateTractReq struct {
	TSID TractserverID
	ID   TractID
	B    []byte
	Off  int64
	Pri  Priority
	// contains filtered or unexported fields
}

type CuratorHeartbeatReply struct {
	// What partitions does the curator own?
	Partitions []PartitionID

	// lib.NoError is everything went OK, otherwise an error representing
	// what went wrong.
	Err Error
}

type CuratorHeartbeatReq struct {
	// What is the ID of this group?
	CuratorID CuratorID

	// Where can we reach the curator?
	Addr string
}

type CuratorID uint32

type CuratorTractserverHeartbeatReply struct {
	// What partitions does the curator have?
	Partitions []PartitionID

	// NoError if everything went OK, otherwise an error representing what
	// went wrong.
	Err Error
}

type CuratorTractserverHeartbeatReq struct {
	// The master assigned ID for the tractserver.
	TSID TractserverID

	// Where can we reach the tractserver?
	Addr string

	// What tracts are corrupt on this tractserver?  These tracts may not be owned by the
	// curator receiving this message, in which case the curator can ignore the entries it
	// doesn't own.
	Corrupt []TractID

	// A subset of tracts owned by this tractserver that we think the curator
	// manages.
	Has []TractID

	// Load state of this tractserver.
	Load TractserverLoad
}

type DiskControlFlags struct {
	// Stop allocating new tracts to this disk, but don't change anything else.
	StopAllocating bool

	// Slowly report this many tracts per second as "corrupt" (non-zero value
	// implies StopAllocating).
	Drain int

	// Slowly try to move this many tracts per second to other disks (non-zero
	// value implies StopAllocating).
	DrainLocal int
}

type DiskStatus struct {
	// Root path
	Root string

	// Is the disk full?
	Full bool

	// Has the disk seen any filesystem corruption?
	Healthy bool

	// What's the current queue length?
	QueueLen int

	// What's the average wait time of an op?
	AvgWaitMs int

	// Manual control flags.
	Flags DiskControlFlags
}

type Error int

type ExtendBlobReply struct {
	Err Error

	// Information for newly allocated tracts.
	NewTracts []TractInfo
}

type ExtendBlobReq struct {
	// The ID of the blob the client wants to extend.
	Blob BlobID

	// If the number of tracts in the blob is less than this, more tracts will be added.
	NumTracts int
}

type FixVersionReq struct {
	// Info is the tract ID, version pair the client was having trouble with.
	Info TractInfo

	// Bad is the address of the tractserver who rejected our version.
	Bad string
}

type FsStatus struct {
	Status DiskStatus        // Basic health information observed during operation.
	Ops    map[string]string // If not nil, per-op information.

	// On-disk information.
	NumTracts        int    // Number of tracts.
	NumDeletedTracts int    // How many tracts have been deleted but not GC-ed?
	NumUnknownFiles  int    // How many files exist but don't look like tracts or former tracts?
	AvailSpace       uint64 // Available space in bytes on the filesystem.
	TotalSpace       uint64 // Total space in bytes on the filesystem.
}

type GCTractReq struct {
	// The tractserver that the curator expects it's talking to.
	TSID TractserverID

	// Outdated tracts that the tractserver can GC.
	Old []TractState

	// Tracts that belong to a deleted blob.
	Gone []TractID
}

type GetDiskInfoReply struct {
	// Disks has one value for each disk in the tractserver.
	Disks []FsStatus
	Err   Error
}

type GetDiskInfoReq struct {
}

type GetTractsReply struct {
	// The tracts that the user asked for.
	// If there are no tracts in the range the user asked for, this is nil.
	// If there are no tracts in the blob, this is nil.
	//
	// Otherwise, Tracts[0] is the GetTractsReq.Start-th tract in the blob,
	// and Tracts contains as many entries as possible, up to (End-Start).
	Tracts []TractInfo

	// Was there any error encountered?  If so, the rest of the fields should be ignored.
	Err Error
}

type GetTractsReq struct {
	// What blob does the client want information for?
	Blob BlobID

	// Get tracts [Start, End) for the blob.
	Start, End int

	// Is the client intending to open this blob for reading or writing (or both)?
	ForRead, ForWrite bool
}

type GetTractserverInfoReply struct {
	Info []TractserverInfo
	Err  Error
}

type GetTractserverInfoReq struct {
}

type ListBlobsReply struct {
	Keys []BlobKey
	Err  Error
}

type ListBlobsReq struct {
	Partition PartitionID
	Start     BlobKey
}

type ListPartitionsReply struct {
	Partitions []PartitionID
	Err        Error
}

type ListPartitionsReq struct {
}

type LookupCuratorReply struct {
	// Replicas[0] is the primary curator, and the rest are secondaries.
	Replicas []string

	// NoError if everything went OK, otherwise an error representing
	// what went wrong.
	Err Error
}

type LookupCuratorReq struct {
	// Find the curator that owns this blobid.
	Blob BlobID
}

type LookupPartitionReply struct {
	// Replicas[0] is the primary curator, and the rest are secondaries.
	Replicas []string

	// NoError if everything went OK, otherwise an error representing
	// what went wrong.
	Err Error
}

type LookupPartitionReq struct {
	// Find the curator that owns this partition.
	Partition PartitionID
}

type MasterCreateBlobReq struct {
}

type MasterTractserverHeartbeatReply struct {
	// Each entry in Curators is the current primary of a Curator replica set.
	Curators []string

	// NoError if everything went OK, otherwise an error representing what
	// went wrong.
	Err Error
}

type MasterTractserverHeartbeatReq struct {
	// What is the ID of this tractserver?
	TractserverID TractserverID

	// Where can we reach the tractserver?
	Addr string

	// Per-disk status
	Disks []FsStatus
}

type NewPartitionReply struct {
	// The new partition that the curator now owns.
	PartitionID PartitionID

	// NoError if everything went OK, otherwise an error representing
	// what went wrong.
	Err Error
}

type NewPartitionReq struct {
	// What is the ID of the requesting curator?
	CuratorID CuratorID
}

type PackTractSpec struct {
	ID      TractID  // tract id
	From    []TSAddr // host(s) that it can be read from
	Version int      // expected version
	Offset  int      // destination offset in packed tract
	Length  int      // expected length
}

type PackTractsReq struct {
	TSID    TractserverID    // The tractserver that the curator expects it's talking to.
	Length  int              // Total length of packed chunk. TS will pad with zeros.
	Tracts  []*PackTractSpec // Tracts to pack. Must be ordered by Offset and must not overlap.
	ChunkID RSChunkID        // What chunk id to write to.
}

type PartitionID uint32

type PartitionType uint32

type Priority int32

type PullTractReq struct {
	// The tractserver that the curator expects it's talking to.
	TSID TractserverID

	// What hosts should we try to pull the tract from? Multiple hosts are
	// provided in case error is encountered and retry is performed from
	// different sources.
	From []string

	// What is the ID of the tract?
	ID TractID

	// And what is the version?
	Version int
}

type RSChunkID struct {
	Partition PartitionID
	ID        uint64 // only lower 48 bits used
}

type RSEncodeReq struct {
	TSID     TractserverID // The tractserver that the curator expects it's talking to.
	ChunkID  RSChunkID     // The starting chunk id for this RS chunk.
	Length   int           // Total length of each piece of the chunk.
	Srcs     []TSAddr      // Where to read the N data pieces from.
	Dests    []TSAddr      // Where to write the M parity pieces to.
	IndexMap []int         // Data indexes for reconstruction (see below).
}

type ReadReply struct {
	Err Error
	B   []byte
	// contains filtered or unexported fields
}

type ReadReq struct {
	ID      TractID
	Version int
	Len     int
	Off     int64
	Pri     Priority

	// ID for cancellation.
	ReqID string
}

type RegisterCuratorReply struct {
	// An ID identifying this curator that must be persisted and used in all further
	// communications.
	CuratorID CuratorID

	// lib.NoError if everything went OK, otherwise an error representing
	// what went wrong.
	Err Error
}

type RegisterCuratorReq struct {
	// Where can we reach the curator?
	Addr string
}

type RegisterTractserverReply struct {
	// An ID identifying this tractserver that must be persisted and used in all further
	// communications.
	TSID TractserverID

	// lib.NoError if everything went OK, otherwise an error representing
	// what went wrong.
	Err Error
}

type RegisterTractserverReq struct {
	// Where we can reach this tractserver.
	Addr string
}

type ReportBadTSReq struct {
	// What tract or RS chunk is problematic?
	ID TractID

	// What host is the client blocked on?
	Bad string

	// What operation were they trying to do? ("read" or "write")
	Operation string

	// What error did they get?
	GotError Error

	// If operation is a read, was the client able to complete the read from
	// another tractserver, or reconstruct erasure-coded data? (If so, the
	// curator may choose to treat this as lower priority.)
	CouldRecover bool
}

type SetControlFlagsReq struct {
	Root  string
	Flags DiskControlFlags
}

type SetMetadataReq struct {
	Blob BlobID

	// Only changing Hint, MTime, ATime, Expires is supported. Other fields are ignored.
	Metadata BlobInfo
}

type SetVersionReply struct {
	// Was there an error handling this request?
	Err Error

	// What version does the tractserver have now?
	NewVersion int
}

type SetVersionReq struct {
	// The tractserver that the curator expects it's talking to.
	TSID TractserverID

	// The ID of the tract we're setting the version on.
	ID TractID

	// What version does the curator want the tractserver to increase to?
	// This will be one more than the current durable version.
	NewVersion int

	// If this is nonzero, the SetVersion is made conditional on the
	// modification stamp of the tract being equal to this value.
	ConditionalStamp uint64
}

type StatBlobReply struct {
	// Was there any error encountered in processing this request?
	// If so, the rest of the fields in this message should be ignored.
	Err Error

	Info BlobInfo
}

type StatTractReply struct {
	Err  Error
	Size int64

	// ModStamp is a value that can be used to detect writes to a tract. If two
	// stat calls return the same modstamp, the tract was definitely not written
	// to in between those calls. If two calls return different mod stamps, the
	// tract may have been written to.
	ModStamp uint64
}

type StatTractReq struct {
	ID      TractID
	Version int
	Pri     Priority
}

type StorageClass int32

type StorageHint int32

type TSAddr struct {
	ID   TractserverID // If 0, don't write out this parity chunk.
	Host string
}

type TractID struct {
	// What blob does this tract belong to?
	Blob BlobID

	// What Index in the blob is this tract?
	Index TractKey
}

type TractInfo struct {
	// The unique ID for the tract.
	Tract TractID

	// Latest version known to Curator.
	// Used to detect stale versions from failed tractservers.
	Version int

	// List of tractservers serving this tract. Maybe be stale.
	Hosts []string

	// The corresponding tractserver IDs.
	TSIDs []TractserverID

	// Pointer to the tract encoded in an RS chunk.
	RS TractPointer
}

type TractKey uint16

type TractPointer struct {
	Chunk  RSChunkID
	Host   string
	TSID   TractserverID
	Offset uint32
	Length uint32

	// Metadata for client-side reconstruction. These are parallel lists
	// containing the location of the other pieces of data that this tract was
	// coded with. Hosts that are known to be down may have "" / 0. If Class is
	// 0 (REPLICATED), OtherHosts/TSIDs are not valid (should be empty).
	Class      StorageClass
	BaseChunk  RSChunkID
	OtherHosts []string
	OtherTSIDs []TractserverID
}

type TractState struct {
	ID      TractID
	Version int
}

type TractserverID uint32

type TractserverInfo struct {
	ID            TractserverID
	Addr          string
	Disks         []FsStatus
	LastHeartbeat time.Time
}

type TractserverLoad struct {
	// How many tracts is this TS currently storing?
	NumTracts int

	// In bytes.
	AvailSpace uint64
	TotalSpace uint64
}

type WriteReq struct {
	ID      TractID
	Version int
	B       []byte
	Off     int64
	Pri     Priority

	// ID for cancellation.
	ReqID string
	// contains filtered or unexported fields
}