elliptics

type AddressBackend struct {
	Addr    RawAddr
	Backend int32
}

type Backend struct {
	Config       Config               `json:"config"`
	GlobalStats  GlobalStats          `json:"global_stats"`
	SummaryStats BlobStats            `json:"summary_stats"`
	BaseStats    map[string]BlobStats `json:"base_stats"`
	VFS          VStat                `json:"vfs"`
	DStat        DStatRaw             `json:"dstat"`
	Error        BackendError         `json:"error"`
}

type BackendError struct {
	Code int32 `json:"code"`
}

type BlobStats struct {
	RecordsTotal       uint64 `json:"records_total"`
	RecordsRemoved     uint64 `json:"records_removed"`
	RecordsRemovedSize uint64 `json:"records_removed_size"`
	RecordsCorrupted   uint64 `json:"records_corrupted"`
	BaseSize           uint64 `json:"base_size"`
	WantDefrag         int32  `json:"want_defrag"`
	IsSorted           int32  `json:"is_sorted"`
}

type ByRawID []DnetRawID

type CStat struct {
	RequestsSuccess  uint64
	RequestsFailures uint64
	Bytes            uint64

	RPSFailures float64
	RPSSuccess  float64
	BPS         float64
}

type Cflag uint64

type Command struct {
	Cache LayerStat `json:"cache"`
	Disk  LayerStat `json:"disk"`
	Total DstStat   `json:"total"`
}

type CommandStat struct {
	Success  uint64 `json:"successes"`
	Failures uint64 `json:"failures"`
	Size     uint64 `json:"size"`
	Time     uint64 `json:"time"`
}

type Config struct {
	Group            uint32 `json:"group"`
	Data             string `json:"data"`
	Sync             int32  `json:"sync"`
	BlobFlags        uint64 `json:"blob_flags"`
	BlobSize         uint64 `json:"blob_size"`
	BlobSizeLimit    uint64 `json:"blob_size_limit"`
	MaxRecords       uint64 `json:"records_in_blob"`
	DefragPercentage uint64 `json:"defrag_percentage"`
	DefragTimeout    uint64 `json:"defrag_timeout"`
	DefragTime       uint64 `json:"defrag_time"`
	DefragSplay      uint64 `json:"defrag_splay"`
}

type DChannel struct {
	In  chan interface{}
	Out chan interface{}
	// contains filtered or unexported fields
}

type DStat struct {
	WSectors uint64
	RSectors uint64
	IOTicks  uint64

	WBS  float64
	RBS  float64
	Util float64
}

type DStatRaw struct {
	ReadIOs      uint64 `json:"read_ios"`
	ReadMerges   uint64 `json:"read_merges"`
	ReadSectors  uint64 `json:"read_sectors"`
	ReadTicks    uint64 `json:"read_ticks"`
	WriteIOs     uint64 `json:"write_ios"`
	WriteMerges  uint64 `json:"write_merges"`
	WriteSectors uint64 `json:"write_sectors"`
	WriteTicks   uint64 `json:"write_ticks"`
	InFlight     uint64 `json:"in_flight"`
	IOTicks      uint64 `json:"io_ticks"`
	TimeInQueue  uint64 `json:"time_in_queue"`
}

type DnetAddr struct {
	Addr   []byte
	Family uint16
}

type DnetBackendStatus struct {
	Backend      int32
	State        int32
	DefragState  int32
	LastStart    time.Time
	LastStartErr int32
	RO           bool
	Delay        uint32
}

type DnetBackendsStatus struct {
	Backends []DnetBackendStatus
	Error    error
}

type DnetCmd struct {
	ID      DnetID
	Status  int32
	Cmd     int32
	Backend int32
	Trace   uint64
	Flags   uint64
	Trans   uint64
	Size    uint64
}

type DnetError struct {
	Code    int
	Flags   uint64
	Message string
}

type DnetFileInfo struct {
	Csum   []byte
	Offset uint64
	Size   uint64
	Mtime  time.Time
}

type DnetID struct {
	ID    []byte
	Group uint32
}

type DnetIOAttr struct {
	Parent []byte
	ID     []byte

	Start uint64
	Num   uint64

	Timestamp time.Time
	UserFlags uint64

	TotalSize uint64

	Flags uint32

	Offset uint64
	Size   uint64

	RecordFlags uint64
}

type DnetIteratorRange struct {
	Begin, End DnetRawID
}

type DnetIteratorResponse struct {
	ID           uint64
	Key          DnetRawID
	Status       int
	Timestamp    time.Time
	UserFlags    uint64
	Size         uint64
	IteratedKeys uint64
	TotalKeys    uint64
	Flags        uint64
}

type DnetRawID struct {
	ID []byte
}

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

type DnetStat struct {
	Time  time.Time
	Group map[uint32]*StatGroup
}

type DstStat struct {
	Storage PacketOnlyCommandStat `json:"storage"`
	Proxy   PacketOnlyCommandStat `json:"proxy"`
}

type GlobalStats struct {
	DataSortStartTime        uint64 `json:"datasort_start_time"`
	DataSortCompletionTime   uint64 `json:"datasort_completion_time"`
	DataSortCompletionStatus int32  `json:"datasort_completion_status"`
}

type IOflag uint32

type IteratorResult interface {
	Reply() *DnetIteratorResponse
	ReplyData() []byte
	ID() uint64
	Error() error
}

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

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

type LayerStat struct {
	Outside  CommandStat `json:"outside"`
	Internal CommandStat `json:"internal"`
}

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

type Lookuper interface {
	// server's reply
	Cmd() *DnetCmd

	// server's address
	Addr() *DnetAddr

	// dnet_file_info structure contains basic information about key location
	Info() *DnetFileInfo

	// address of the node which hosts given key
	StorageAddr() *DnetAddr

	//Path returns a path to file hosting given key on the storage.
	Path() string

	//Error returns string respresentation of error.
	Error() error
}

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

type NodeConfig struct {
	IOThreadNum            int    `json:"io-thread-num"`
	NonBlockingIOThreadNum int    `json:"nonblocking-io-thread-num"`
	NetThreadNum           int    `json:"net-thread-num"`
	WaitTimeout            uint64 `json:"wait-timeout"`
	CheckTimeout           uint64 `json:"check-timeout"`
	Flags                  int    `json:"flags"`
	StallCount             int    `json:"stall-count"`
}

type PID struct {
	sync.RWMutex

	Error         float64
	IntegralError float64
	ErrorTime     time.Time
	Pain          float64
}

type PacketOnlyCommandStat struct {
	Success  uint64 `json:"successes"`
	Failures uint64 `json:"failures"`
}

type RawAddr struct {
	Addr   [32]byte
	Len    int
	Family uint16
}

type ReadResult interface {
	// server's reply
	Cmd() *DnetCmd

	// server's address
	Addr() *DnetAddr

	// IO parameters for given
	IO() *DnetIOAttr

	//Data returns string represntation of read data
	Data() []byte

	// read error
	Error() error
}

type ReadSeeker struct {
	TotalSize   uint64
	RecordFlags uint64

	Mtime time.Time
	// contains filtered or unexported fields
}

type Remover interface {
	// server's reply
	Cmd() *DnetCmd

	// key to be removed, only set for error results
	Key() string

	//Error of remove operation.
	Error() error
}

type Response struct {
	Timestamp     Time               `json:"timestamp"`
	MonitorStatus string             `json:"monitor_status"`
	Backends      map[string]VNode   `json:"backends"`
	Commands      map[string]Command `json:"commands"`
}

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

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

type StatBackend struct {
	// Address+Backend for given stats, do not put it into json
	// since @RawAddr is an array of bytes and it can not be parsed by human
	Ab AddressBackend `json:"-"`

	Error BackendError `json:"error"`

	// All range starts (IDs) for given node (server address + backend)
	ID []DnetRawID `json:"-"`

	// percentage of the whole IDs ring currently occupied by given ids
	// and thus node (address + backend)
	Percentage float64

	// defragmentation status: 0 - not started, 1 - in progress
	DefragState            int32
	DefragStateStr         string
	DefragStartTime        time.Time
	DefragCompletionTime   time.Time
	DefragCompletionStatus int32

	// backend is in read-only mode
	RO bool

	// backend has delay of @Delay ms for every operation
	Delay uint32

	// VFS statistics: available, used and total space
	VFS VFS

	// PID-controller used for data writing
	PID *PID

	// per-command size/number counters
	// difference between the two divided by the time difference equals to RPS/BPS
	Commands map[string]*CStat
	// contains filtered or unexported fields
}

type StatBackendData struct {
	Address string
	Backend int32
	Stat    *StatBackend
}

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

type StatGroup struct {
	Ab map[AddressBackend]*StatBackend
}

type StatGroupData struct {
	Backends []*StatBackendData
}

type Status struct {
	State        int32  `json:"state"`
	DefragState  int32  `json:"defrag_state"`
	LastStart    Time   `json:"last_start"`
	LastStartErr int32  `json:"last_start_err"`
	RO           bool   `json:"read_only"`
	Delay        uint32 `json:"delay"`
}

type Time struct {
	Sec  uint64 `json:"tv_sec"`
	USec uint64 `json:"tv_usec"`
}

type TraceID C.trace_id_t

type VFS struct {
	// space in bytes for given backend
	Total, Avail uint64

	// logical size limitation for backends which support it
	// blob backend may set this (configuration must allow blob size checks, bit-4 must be zero)
	// for all others this field equals to @VFS.Total
	TotalSizeLimit uint64

	BackendRemovedSize uint64
	BackendUsedSize    uint64

	RecordsTotal     uint64
	RecordsRemoved   uint64
	RecordsCorrupted uint64
}

type VNode struct {
	BackendID int                `json:"backend_id"`
	Status    Status             `json:"status"`
	Backend   Backend            `json:"backend"`
	Commands  map[string]Command `json:"commands"`
}

type VStat struct {
	BSize  uint64 `json:"bsize"`
	FrSize uint64 `json:"frsize"`
	Blocks uint64 `json:"blocks"`
	BFree  uint64 `json:"bfree"`
	BAvail uint64 `json:"bavail"`
}

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