types

type ClusterStats interface {
	InstanceLen() int
	InstanceStats(int) InstanceStats
	AllInstancesStats() Iterator
	InstanceStatsFromIterator(Iterator) (int, InstanceStats)
	MetaStats() MetaStoreStats
}

type Command interface {
	Name() string
	String() string
	GetInfo() interface{}
	GetRequest() *Request
	// MarkError Mark an failure attempt to send request, return attempts left.
	MarkError(error) int
	// LastError Get last failure attempt, return attempts left and last error.
	LastError() (int, error)
	// FailureError Get error for failure (no attempt left.)
	FailureError() error
	Flush() error
}

type Conn interface {
	net.Conn
	Writer() *resp.RequestWriter
}

type Control struct {
	Cmd        string
	Addr       string
	Deployment string
	Id         uint64
	Info       interface{}
	Payload    []byte
	*Request

	Callback ControlCallback
	// contains filtered or unexported fields
}

type ControlCallback func(*Control, interface{})

type GroupedClusterStats interface {
	ClusterLen() int
	ClusterStats(int) ClusterStats
	AllClustersStats() Iterator
	ClusterStatsFromIterator(Iterator) (int, ClusterStats)
	MetaStats() MetaStoreStats
}

type Id struct {
	ReqId   string
	ChunkId string
	// contains filtered or unexported fields
}

type InstanceOccupancyMode int

type InstanceStats interface {
	Status() uint64
	Occupancy(InstanceOccupancyMode) float64
}

type Iterator interface {
	Len() int
	Next() bool
	Value() (int, interface{})
}

type LambdaDeployment interface {
	Name() string
	Id() uint64
}

type MetaStoreStats interface {
	Len() int
}

type MigrationScheduler interface {
	StartMigrator(uint64) (string, error)
	GetDestination(uint64) (LambdaDeployment, error)
}

type PersistCache interface {
	// Len returns the number of chunks in the cache.
	Len() int

	// Get returns a PersistChunk instance by specified key.
	// This call is read-after-write safe because the key(chunk key) will only
	// be available to get request after an earlier write request was finished.
	GetOrCreate(key string, size int64) (chunk PersistChunk, first bool)

	// Get will return a existed PersistChunk, nil if not found.
	Get(key string) PersistChunk

	// Restore restores the cache from local storage.
	Restore() error

	// Report outputs the cache status.
	Report()
}

type PersistChunk interface {
	redeo.Contextable
	PersistChunkForResponse

	// Key returns the key of the chunk.
	Key() string

	// Size returns the size of the chunk.
	Size() int64

	// Store stores the chunk by intercepting a stream.
	Store(resp.AllReadCloser) (resp.AllReadCloser, error)

	// GetInterceptor returns the interceptor that returns on calling Store().
	GetInterceptor() resp.AllReadCloser

	// WaitStored waits for the chunk to be stored or error occurred.
	WaitStored() error

	// Load loads the data by returning a stream.
	Load(context.Context) (resp.AllReadCloser, error)

	// LoadAll loads the data by returning the fully loaded data, wait if not fully loaded.
	LoadAll(context.Context) ([]byte, error)

	// StartPersist instructs the chunk to avoid from being closed before persisted to COS.
	StartPersist(req interface{}, timeout time.Duration, retry PersistRetrier)

	// DonePersist instructs the chunk persistencing has concluded, either success or failure.
	DonePersist()

	// Error returns the error occurred during storing chunk.
	Error() error

	// Close closes the chunk to be removed from the cache.
	Close()

	// Close closes the chunk with specified error.
	CloseWithError(err error)

	// CanClose returns true if there is no Load() pending.
	CanClose() bool

	// IsClosed returns true if the chunk is closed.
	IsClosed() bool
}

type PersistChunkForResponse interface {
	// IsStored returns whether the chunk is fully stored.
	IsStored() bool

	// ByteStored returns how many bytes is stored.
	BytesStored() int64
}

type PersistRetrier func(PersistChunk)

type ProxyResponse interface {
	redeo.Contextable
	Request() *Request
	Response() interface{}
}

type Request struct {
	Seq            int64
	Id             Id
	InsId          uint64 // Instance the request targeted.
	Cmd            string
	Key            string
	RetCommand     string
	BodySize       int64
	Body           []byte
	BodyStream     resp.AllReadCloser
	Info           interface{}
	Changes        int
	CollectorEntry interface{}
	Option         int64
	RequestGroup   RequestGroup
	PersistChunk   PersistChunk
	PredictedDue   time.Duration

	// Added by Tianium 20221102
	AllDone      bool // Is sharded request done after chunk request
	AllSucceeded bool // Is sharded request succeeded after chunk request
	// contains filtered or unexported fields
}

type RequestGroup interface {
	MarkReturnd(*Id) (uint64, bool)
	IsFulfilled(status ...uint64) bool
	IsAllReturned(status ...uint64) bool
	Close()
}

type Response struct {
	util.Closer
	protocol.Contextable

	Id   Id
	Cmd  string
	Size string
	Body []byte

	Status int64 // Customized status. For GET: 1 - recovered
	// contains filtered or unexported fields
}

type ResponseFinalizer func(*Response)

type ScaleEvent struct {
	// BaseInstance Instance that triggers the scaling event.
	BaseInstance interface{}

	// ScaleTarget The number of instances to scale.
	ScaleTarget int

	// Scaled A promise object that can be used to wait for the completion of the scaling event.
	Scaled promise.Promise

	// Retire If there is insufficient space in BaseInstance, set to true to retire it.
	Retire bool

	// Reason for logging.
	Reason string
}

type ServerStats interface {
	PersistCacheLen() int
}

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