blobcache

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

type BlobCacheClientConfig struct {
	Token                 string       `key:"token" json:"token"`
	MinRetryLengthBytes   int64        `key:"minRetryLengthBytes" json:"min_retry_length_bytes"`
	MaxGetContentAttempts int          `key:"maxGetContentAttempts" json:"max_get_content_attempts"`
	NTopHosts             int          `key:"nTopHosts" json:"n_top_hosts"`
	BlobFs                BlobFsConfig `key:"blobfs" json:"blobfs"`
}

type BlobCacheConfig struct {
	Server  BlobCacheServerConfig  `key:"server" json:"server"`
	Client  BlobCacheClientConfig  `key:"client" json:"client"`
	Global  BlobCacheGlobalConfig  `key:"global" json:"global"`
	Metrics BlobCacheMetricsConfig `key:"metrics" json:"metrics"`
}

type BlobCacheGlobalConfig struct {
	DefaultLocality                 string  `key:"defaultLocality" json:"default_locality"`
	CoordinatorHost                 string  `key:"coordinatorHost" json:"coordinator_host"`
	ServerPort                      uint    `key:"serverPort" json:"server_port"`
	DiscoveryIntervalS              int     `key:"discoveryIntervalS" json:"discovery_interval_s"`
	RoundTripThresholdMilliseconds  uint    `key:"rttThresholdMilliseconds" json:"rtt_threshold_ms"`
	HostStorageCapacityThresholdPct float64 `key:"hostStorageCapacityThresholdPct" json:"host_storage_capacity_threshold_pct"`
	GRPCDialTimeoutS                int     `key:"grpcDialTimeoutS" json:"grpc_dial_timeout_s"`
	GRPCMessageSizeBytes            int     `key:"grpcMessageSizeBytes" json:"grpc_message_size_bytes"`
	GRPCInitialWindowSize           int     `key:"grpcInitialWindowSize" json:"grpc_initial_window_size"`
	GRPCInitialConnWindowSize       int     `key:"grpcInitialConnWindowSize" json:"grpc_initial_conn_window_size"`
	GRPCWriteBufferSize             int     `key:"grpcWriteBufferSize" json:"grpc_write_buffer_size"`
	GRPCReadBufferSize              int     `key:"grpcReadBufferSize" json:"grpc_read_buffer_size"`
	GRPCMaxConcurrentStreams        int     `key:"grpcMaxConcurrentStreams" json:"grpc_max_concurrent_streams"`
	GRPCNumStreamWorkers            int     `key:"grpcNumStreamWorkers" json:"grpc_num_stream_workers"`
	DebugMode                       bool    `key:"debugMode" json:"debug_mode"`
	PrettyLogs                      bool    `key:"prettyLogs" json:"pretty_logs"`
}

type BlobCacheHost struct {
	RTT              time.Duration `redis:"rtt" json:"rtt"`
	HostId           string        `redis:"host_id" json:"host_id"`
	Addr             string        `redis:"addr" json:"addr"`
	PrivateAddr      string        `redis:"private_addr" json:"private_addr"`
	CapacityUsagePct float64       `redis:"capacity_usage_pct" json:"capacity_usage_pct"`
}

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

type BlobCacheMetadataMode string

type BlobCacheMetricsConfig struct {
	PushIntervalS int    `key:"pushIntervalS" json:"push_interval_s"`
	URL           string `key:"url" json:"url"`
	Username      string `key:"username" json:"username"`
	Password      string `key:"password" json:"password"`
}

type BlobCacheServerConfig struct {
	Mode                  BlobCacheServerMode `key:"mode" json:"mode"`
	DiskCacheDir          string              `key:"diskCacheDir" json:"disk_cache_dir"`
	DiskCacheMaxUsagePct  float64             `key:"diskCacheMaxUsagePct" json:"disk_cache_max_usage_pct"`
	EnableMemoryCache     bool                `key:"enableMemoryCache" json:"enable_memory_cache"`
	Token                 string              `key:"token" json:"token"`
	PrettyLogs            bool                `key:"prettyLogs" json:"pretty_logs"`
	ObjectTtlS            int                 `key:"objectTtlS" json:"object_ttl_s"`
	MaxCachePct           int64               `key:"maxCachePct" json:"max_cache_pct"`
	PageSizeBytes         int64               `key:"pageSizeBytes" json:"page_size_bytes"`
	Metadata              MetadataConfig      `key:"metadata" json:"metadata"`
	Sources               []SourceConfig      `key:"sources" json:"sources"`
	S3DownloadConcurrency int64               `key:"s3DownloadConcurrency" json:"s3_download_concurrency"`
	S3DownloadChunkSize   int64               `key:"s3DownloadChunkSize" json:"s3_download_chunk_size"`

	// Allows a coordinator to override a slave server's config for a specific locality/region
	Regions map[string]RegionConfig `key:"regions" json:"regions"`
}

type BlobCacheServerMode string

type BlobFs struct {
	CoordinatorClient CoordinatorClient
	Client            *BlobCacheClient
	Config            BlobCacheClientConfig
	// contains filtered or unexported fields
}

type BlobFsConfig struct {
	Enabled            bool     `key:"enabled" json:"enabled"`
	MountPoint         string   `key:"mountPoint" json:"mount_point"`
	MaxBackgroundTasks int      `key:"maxBackgroundTasks" json:"max_background_tasks"`
	MaxWriteKB         int      `key:"maxWriteKB" json:"max_write_kb"`
	MaxReadAheadKB     int      `key:"maxReadAheadKB" json:"max_read_ahead_kb"`
	DirectMount        bool     `key:"directMount" json:"direct_mount"`
	DirectIO           bool     `key:"directIO" json:"direct_io"`
	Options            []string `key:"options" json:"options"`
}

type BlobFsMetadata struct {
	PID       string `redis:"pid" json:"pid"`
	ID        string `redis:"id" json:"id"`
	Name      string `redis:"name" json:"name"`
	Path      string `redis:"path" json:"path"`
	Hash      string `redis:"hash" json:"hash"`
	Ino       uint64 `redis:"ino" json:"ino"`
	Size      uint64 `redis:"size" json:"size"`
	Blocks    uint64 `redis:"blocks" json:"blocks"`
	Atime     uint64 `redis:"atime" json:"atime"`
	Mtime     uint64 `redis:"mtime" json:"mtime"`
	Ctime     uint64 `redis:"ctime" json:"ctime"`
	Atimensec uint32 `redis:"atimensec" json:"atimensec"`
	Mtimensec uint32 `redis:"mtimensec" json:"mtimensec"`
	Ctimensec uint32 `redis:"ctimensec" json:"ctimensec"`
	Mode      uint32 `redis:"mode" json:"mode"`
	Nlink     uint32 `redis:"nlink" json:"nlink"`
	Rdev      uint32 `redis:"rdev" json:"rdev"`
	Blksize   uint32 `redis:"blksize" json:"blksize"`
	Padding   uint32 `redis:"padding" json:"padding"`
	Uid       uint32 `redis:"uid" json:"uid"`
	Gid       uint32 `redis:"gid" json:"gid"`
	Gen       uint64 `redis:"gen" json:"gen"`
}

type BlobFsNode struct {
	Path     string
	ID       string
	PID      string
	Name     string
	Target   string
	Hash     string
	Attr     fuse.Attr
	Prefetch *bool
}

type BlobFsSystemOpts struct {
	Verbose           bool
	CoordinatorClient CoordinatorClient
	Config            BlobCacheClientConfig
	Client            *BlobCacheClient
}

type BlobcacheMetrics struct {
	DiskCacheUsageMB  *metrics.Histogram
	DiskCacheUsagePct *metrics.Histogram
	MemCacheUsageMB   *metrics.Histogram
	MemCacheUsagePct  *metrics.Histogram

	// Cache tier hit ratios
	L0HitRatio  *metrics.Histogram // In-memory cache hits
	L1HitRatio  *metrics.Histogram // Disk cache hits
	L2MissRatio *metrics.Histogram // Remote fetch required

	// Operation counters
	L0Hits     *metrics.Counter
	L1Hits     *metrics.Counter
	L2Misses   *metrics.Counter
	TotalReads *metrics.Counter

	// Bytes served per tier
	L0BytesServed  *metrics.Counter
	L1BytesServed  *metrics.Counter
	L2BytesFetched *metrics.Counter

	// FUSE operation latencies
	FUSEReadLatency    *metrics.Histogram
	FUSELookupLatency  *metrics.Histogram
	FUSEGetattrLatency *metrics.Histogram

	// Read throughput
	ReadThroughputMBps *metrics.Histogram
}

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

type CacheService struct {
	proto.UnimplementedBlobCacheServer
	// contains filtered or unexported fields
}

type CacheServiceOpts struct {
	Addr string
}

type ClientOptions struct {
	RoutingKey string
}

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

type ClientRequestType int

type ConfigFormat string

type ConfigLoaderFunc func(k *koanf.Koanf) error

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

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

type CoordinatorClient interface {
	AddHostToIndex(ctx context.Context, locality string, host *BlobCacheHost) error
	SetHostKeepAlive(ctx context.Context, locality string, host *BlobCacheHost) error
	GetAvailableHosts(ctx context.Context, locality string) ([]*BlobCacheHost, error)
	GetRegionConfig(ctx context.Context, locality string) (BlobCacheServerConfig, error)
	SetClientLock(ctx context.Context, hash string, host string) error
	RemoveClientLock(ctx context.Context, hash string, host string) error
	SetStoreFromContentLock(ctx context.Context, locality string, sourcePath string) error
	RemoveStoreFromContentLock(ctx context.Context, locality string, sourcePath string) error
	RefreshStoreFromContentLock(ctx context.Context, locality string, sourcePath string) error
	SetFsNode(ctx context.Context, id string, metadata *BlobFsMetadata) error
	GetFsNode(ctx context.Context, id string) (*BlobFsMetadata, error)
	RemoveFsNode(ctx context.Context, id string) error
	RemoveFsNodeChild(ctx context.Context, pid, id string) error
	GetFsNodeChildren(ctx context.Context, id string) ([]*BlobFsMetadata, error)
	AddFsNodeChild(ctx context.Context, pid, id string) error
}

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

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

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

type ErrNodeNotFound struct {
	Id string
}

type FSNode struct {
	fs.Inode
	// contains filtered or unexported fields
}

type FileSystem interface {
	Mount(opts FileSystemOpts) (func() error, <-chan error, error)
	Unmount() error
	Format() error
}

type FileSystemOpts struct {
	MountPoint string
	Verbose    bool
	Metadata   *BlobCacheMetadata
}

type FileSystemStorage interface {
	Metadata()
	Get(string)
	ReadFile(interface{}, []byte, int64)
}

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

type JuiceFSConfig struct {
	RedisURI   string `key:"redisURI" json:"redis_uri"`
	Bucket     string `key:"bucket" json:"bucket"`
	AccessKey  string `key:"accessKey" json:"access_key"`
	SecretKey  string `key:"secretKey" json:"secret_key"`
	CacheSize  int64  `key:"cacheSize" json:"cache_size"`
	BlockSize  int64  `key:"blockSize" json:"block_size"`
	Prefetch   int64  `key:"prefetch" json:"prefetch"`
	BufferSize int64  `key:"bufferSize" json:"buffer_size"`
}

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

type MetadataConfig struct {
	Mode         BlobCacheMetadataMode `key:"mode" json:"mode"`
	ValkeyConfig ValkeyConfig          `key:"valkey" json:"valkey"`

	// Default config
	RedisAddr       string    `key:"redisAddr" json:"redis_addr"`
	RedisPasswd     string    `key:"redisPasswd" json:"redis_passwd"`
	RedisTLSEnabled bool      `key:"redisTLSEnabled" json:"redis_tls_enabled"`
	RedisMode       RedisMode `key:"redisMode" json:"redis_mode"`
	RedisMasterName string    `key:"redisMasterName" json:"redis_master_name"`
}

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

type MountPointConfig struct {
	BucketName     string `key:"bucketName" json:"bucket_name"`
	AccessKey      string `key:"accessKey" json:"access_key"`
	SecretKey      string `key:"secretKey" json:"secret_key"`
	Region         string `key:"region" json:"region"`
	EndpointURL    string `key:"endpointUrl" json:"endpoint_url"`
	ForcePathStyle bool   `key:"forcePathStyle" json:"force_path_style"`
}

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

type ParserFunc func() (koanf.Parser, error)

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

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

type RedisClient struct {
	redis.UniversalClient
}

type RedisConfig struct {
	Addrs              []string      `key:"addrs" json:"addrs"`
	Mode               RedisMode     `key:"mode" json:"mode"`
	ClientName         string        `key:"clientName" json:"client_name"`
	EnableTLS          bool          `key:"enableTLS" json:"enable_tls"`
	InsecureSkipVerify bool          `key:"insecureSkipVerify" json:"insecure_skip_verify"`
	MinIdleConns       int           `key:"minIdleConns" json:"min_idle_conns"`
	MaxIdleConns       int           `key:"maxIdleConns" json:"max_idle_conns"`
	ConnMaxIdleTime    time.Duration `key:"connMaxIdleTime" json:"conn_max_idle_time"`
	ConnMaxLifetime    time.Duration `key:"connMaxLifetime" json:"conn_max_lifetime"`
	DialTimeout        time.Duration `key:"dialTimeout" json:"dial_timeout"`
	ReadTimeout        time.Duration `key:"readTimeout" json:"read_timeout"`
	WriteTimeout       time.Duration `key:"writeTimeout" json:"write_timeout"`
	MaxRedirects       int           `key:"maxRedirects" json:"max_redirects"`
	MaxRetries         int           `key:"maxRetries" json:"max_retries"`
	PoolSize           int           `key:"poolSize" json:"pool_size"`
	Username           string        `key:"username" json:"username"`
	Password           string        `key:"password" json:"password"`
	RouteByLatency     bool          `key:"routeByLatency" json:"route_by_latency"`
	MasterName         string        `key:"masterName" json:"master_name"`
	SentinelPassword   string        `key:"sentinelPassword" json:"sentinel_password"`
}

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

type RedisLockOption func(*RedisLock)

type RedisLockOptions struct {
	TtlS    int
	Retries int
}

type RedisMode string

type RegionConfig struct {
	ServerConfig BlobCacheServerConfig `key:"server" json:"server"`
}

type RendezvousHasher interface {
	Add(hosts ...*BlobCacheHost)
	Remove(host *BlobCacheHost)
	GetN(n int, key string) []*BlobCacheHost
}

type S3Client struct {
	Client              *s3.Client
	Source              S3SourceConfig
	DownloadConcurrency int64
	DownloadChunkSize   int64
}

type S3SourceConfig struct {
	BucketName  string
	Region      string
	EndpointURL string
	AccessKey   string
	SecretKey   string
}

type Source interface {
	Mount(localPath string) error
	Format(fsName string) error
	Unmount(localPath string) error
}

type SourceConfig struct {
	Mode           string           `key:"mode" json:"mode"`
	FilesystemName string           `key:"fsName" json:"filesystem_name"`
	FilesystemPath string           `key:"fsPath" json:"filesystem_path"`
	JuiceFS        JuiceFSConfig    `key:"juicefs" json:"juicefs"`
	MountPoint     MountPointConfig `key:"mountpoint" json:"mountpoint"`
}

type StorageLayer interface {
}

type ValkeyConfig struct {
	PrimaryName     string                `key:"primaryName" json:"primary_name"`
	Password        string                `key:"password" json:"password"`
	TLS             bool                  `key:"tls" json:"tls"`
	Host            string                `key:"host" json:"host"`
	Port            int                   `key:"port" json:"port"`
	ExistingPrimary ValkeyExistingPrimary `key:"existingPrimary" json:"existingPrimary"`
}

type ValkeyExistingPrimary struct {
	Host string `key:"host" json:"host"`
	Port int    `key:"port" json:"port"`
}