server

type ABFSClient interface {
	Close() error
	AddMapResult(ctx context.Context, from, to entities.Hash) error
	GetObject(ctx context.Context, key remote.Hash) (remote.ContentReadCloser, error)
	GetRefs(ctx context.Context, server string, project string, refs []string) ([]entities.Hash, error)
	Headers(ctx context.Context, keys []remote.Hash) ([]entities.ObjectHeader, error)
	SHA256(ctx context.Context, keys []remote.Hash) ([]entities.SHA256, error)
	MapResults(ctx context.Context, id entities.Hash) ([]entities.Hash, error)
	PutObject(ctx context.Context, key remote.Hash, reader remote.ContentReadCloser) error
	PutRefs(ctx context.Context, server string, project string, refs []entities.RefHash) error
	SearchRefs(ctx context.Context, server string, project string, refPrefix string, limit int) ([]entities.ProjectRefHash, error)
	Mark(ctx context.Context, hash entities.Hash, key, value string) (int64, error)
	Version(ctx context.Context) (string, error)
	WhoAmI(ctx context.Context) (string, error)
}

type ARESClient interface {
	remote.ARESService
	// Support returns whether remote execution is available
	Support() bool
}

type BadgerIndexStore struct {
	BaseBadgerStore
	// contains filtered or unexported fields
}

type BadgerMapsStore struct {
	BaseBadgerStore
	// contains filtered or unexported fields
}

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

type BlockingQueue[T any] struct {
	// contains filtered or unexported fields
}

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

type CheckCredsFunc func(ctx context.Context) error

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

type DefaultPrinter struct {
}

type EmptyIndex struct{}

type EntryType int

type FetchReq struct {
	Hash      entities.Hash
	ARI       string
	SHA256Hex string
	Size      int64
	Priority  float64
	Time      time.Time
	ObjType   protocol.RequestObjectType
	// contains filtered or unexported fields
}

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

type Index interface {
	Get(hash entities.Hash) *IndexEntry
	Put(hash entities.Hash, entry *IndexEntry) (newSize int64, newLRUSize int64, prevEnt, newEnt *IndexEntry, err error)
	PutMany(entries []*IndexKeyEntry) (newSize int64, newLRUSize int64, err error)
	EvictCount() int64
	LockEviction() func()
	Delete(hash entities.Hash) error
	EntriesWithTotalSize() ([]*IndexKeyEntry, uint64, error)
	TotalSize() uint64
	ReadLRU() ([]KeyTimestamp, error)
	Use(hash entities.Hash) error
	Close() error
	KeepAlive(key entities.Hash) error
	Sweep(timestampThreshold int64) (deletedCount int, err error)

	// Metrics and internal status getters
	LRUSize() int64
	LocalCount() int64
	IndexCount() int64
	GCStart() time.Time
	GCEnd() time.Time
	EvictStart() time.Time
	EvictEnd() time.Time
	OldestUsed() time.Time

	// Internal/store methods exposed for direct usage
	UseMany(hashes []entities.Hash) error
	DeleteMany(hashes []entities.Hash) (int64, int64, error)
	ForEach(fn func(key entities.Hash, entry *IndexEntry, expiresAt uint64) error) error
	// contains filtered or unexported methods
}

type IndexEntry struct {
	EntryType EntryType `json:",omitempty"`

	// Content exists as a loose file.
	// We do not currently use this field,
	// it is plumbing for the future.
	Loose bool `json:",omitempty"`

	// Object is Local.
	// We do not currently use this field,
	// it is plumbing for the future.
	Local bool `json:",omitempty"`

	// Content has been pushed to remote.
	Remote bool `json:",omitempty"`

	// Content should not be pushed to remote.
	Offline bool `json:",omitempty"`

	// Size in bytes of the content, if known.
	Size uint64 `json:",omitempty"`

	// It will used for garbage collection
	LastAliveTime time.Time `json:",omitempty"`
}

type IndexKeyEntry struct {
	Key entities.Hash
	*IndexEntry
}

type IndexOptions struct {
	IndexStore     IndexStore
	Cache          *localcache.LocalCache
	EvictThreshold uint64
	Printer        Printer
	LogDir         string
}

type IndexReq struct {
	Hash      entities.Hash
	EntryType EntryType
	ObjType   protocol.RequestObjectType
	ReqStat   *protocol.QueueStat
	RawType   string
	// Size carries the known on-disk size computed during fetch to avoid redundant disk I/O in indexObjectsWorker.
	Size int64
}

type IndexReqQueue = BlockingQueue[IndexReq]

type IndexStore interface {
	// Open must be called on any store prior to use.
	Open() error

	// Get returns the index entry associated with the hash, or
	// nil if one cannot be found.
	Get(hash entities.Hash) *IndexEntry

	// Put adds an index entry to the store and returns both the updated total size of the index,
	// and the updated total LRU Size.
	// If the entry already exists, it is not completely replaced, but rather merged.
	// This prevents clobbering of state like 'Remote'.
	// Callers may want to implement a retry mechanism in case of transaction conflicts.
	Put(hash entities.Hash, entry *IndexEntry) (newSize int64, newLRUSize int64, prevEnt, newEnt *IndexEntry, err error)

	// PutMany adds multiple index entries to the store and returns both the updated total size of the index,
	// and the updated total LRU Size.
	PutMany(entries []*IndexKeyEntry) (newSize int64, newLRUSize int64, err error)

	// ForEach iterates over the keys and values and calls the provided function.
	ForEach(fn func(key entities.Hash, entry *IndexEntry, expiresAt uint64) error) error

	// MarkObjectRemote marks an existing entry as Remote.
	MarkObjectRemote(key entities.Hash) error

	// MarkObjectOffline marks an existing entry as Offline.
	MarkObjectOffline(key entities.Hash) error

	// Delete removes the index entry and LRU information associated with the hash.
	// It returns the deleted key and the index size after the deletion.
	// Returns nil on non-existent entry.
	Delete(hash entities.Hash) (*IndexKeyEntry, int64, int64, error)

	// DeleteMany removes multiple hashes from the index.
	// It returns the index size and lru size after all the deletions.
	// Non-existent entries are ignored.
	DeleteMany(hashes []entities.Hash) (int64, int64, error)

	// Use should be called to update LRU tracking information.
	Use(hash entities.Hash) error

	// UseMany can be used to "touch" multiple objects.
	UseMany(hashes []entities.Hash) error

	// Evict returns the evicted key entries and the size of the index after
	// the deletion.
	Evict() ([]*IndexKeyEntry, int64, int64, error)

	// ReadAll returns all index entries.
	ReadAll() ([]*IndexKeyEntry, error)

	// ReadLRU returns the LRU list in oldest->newest order.
	ReadLRU() ([]KeyTimestamp, error)

	// PeekOldest returns the oldest item in the LRU list.
	PeekOldest() (KeyTimestamp, error)

	// TotalSize returns the size of the entries tracked by the index,
	// not the size of the index metadata itself.
	TotalSize() int64

	// LRUSize returns the size of the entries tracked in LRU.
	LRUSize() int64

	LocalCount() int64

	IndexCount() int64

	GCStart() time.Time
	GCEnd() time.Time

	// Close closes the store.
	Close() error

	// KeepAlive should be called to update the last alive time of the entry.
	KeepAlive(key entities.Hash) error
}

type KeyTimestamp struct {
	Key       entities.Hash
	Timestamp int64
}

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

type MapsStore interface {
	// Open must be called on any store prior to use.
	Open() error

	// Get returns all mappings for 'from'.
	Get(from entities.Hash) ([]entities.Hash, error)

	// Put adds a 'from'->'to' mapping.
	Put(from, to entities.Hash) error

	// Close closes the store.
	Close() error
}

type NewARESFunc func(address string, authInfo instance.AuthInfo) (remote.ARESService, error)

type NewObjectReq struct {
	Hash    entities.Hash
	ObjType protocol.RequestObjectType
}

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

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

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

type Printer interface {
	Printf(format string, a ...any)
	Println(a ...any)

	Fatalf(format string, a ...any)
	Fatal(a ...any)

	Close() error
}

type RelativeFetchReq struct {
	FetchReq
	FetchStat   *relativeFetchStat
	RequestType entities.ObjectType
}

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

type StatStore interface {
	Put(key entities.Hash, stat entities.StatInfo) error
	Get(key entities.Hash) (entities.StatInfo, bool)
}

type TunnelCommand interface {
	Start() error
	Wait() error
	Kill() error
}