cache

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

type CacheChurnEvent struct {
	Operation           string
	Status              string
	Path                string
	EvictedObjects      int
	ProtectedObjects    int
	FreedBytes          int64
	ProtectedFreedBytes int64
	UsagePct            float64
	WatermarkPct        float64
	AvailableBytes      uint64
	ReserveBytes        int64
	TargetFreeBytes     int64
	TotalCandidates     int
	ProtectedCandidates int
	RecentCandidates    int
	EligibleCandidates  int
	Timestamp           time.Time
}

type CacheChurnSink func(CacheChurnEvent)

type CacheFS struct {
	MetadataStore CacheMetadataStore
	Client        *Client
	Config        ClientConfig
	// contains filtered or unexported fields
}

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

type CacheMetadataStore interface {
	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 *FSMetadata) error
	GetFsNode(ctx context.Context, id string) (*FSMetadata, error)
	RemoveFsNode(ctx context.Context, id string) error
	RemoveFsNodeChild(ctx context.Context, pid, id string) error
	GetFsNodeChildren(ctx context.Context, id string) ([]*FSMetadata, error)
	AddFsNodeChild(ctx context.Context, pid, id string) error

	// Required-content reconciliation state. On workers these are brokered to
	// the gateway/coordinator over gRPC; the gateway implements them against
	// its Redis.
	AddRecentStub(ctx context.Context, locality, workspaceID, stubID string, ttl time.Duration) error
	ListRecentStubs(ctx context.Context, locality string, ttl time.Duration, limit int) ([]RecentStub, error)
	MarkStubReported(ctx context.Context, locality, stubID string, ttl time.Duration) (bool, error)
	AcquireReconcileLock(ctx context.Context, locality, logicalHost, hash string, ttlSeconds int) (bool, error)
	ReleaseReconcileLock(ctx context.Context, locality, logicalHost, hash string) error
}

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

type ClientConfig 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"`
	CacheFS               FSConfig                  `key:"cachefs" json:"cachefs"`
	PreferLocalCacheHost  bool                      `key:"preferLocalCacheHost" json:"prefer_local_cache_host"`
	PageFDCacheSize       int                       `key:"pageFDCacheSize" json:"page_fd_cache_size"`
	ReadTransport         ClientReadTransportConfig `key:"readTransport" json:"read_transport"`
	Prefetch              ReadPrefetchConfig        `key:"prefetch" json:"prefetch"`
}

type ClientLocalPageFileView struct {
	Path   string
	Offset int64
	Length int
}

type ClientOptions = struct {
	RoutingKey string
}

type ClientReadTransportConfig struct {
	Enabled               bool `key:"enabled" json:"enabled"`
	MaxActiveConnsPerHost int  `key:"maxActiveConnsPerHost" json:"max_active_conns_per_host"`
	MaxIdleConnsPerHost   int  `key:"maxIdleConnsPerHost" json:"max_idle_conns_per_host"`
	// RequestSizeBytes bounds each raw TCP request independently of the
	// server-side page prefetch part size.
	RequestSizeBytes int64 `key:"requestSizeBytes" json:"request_size_bytes"`
	// MaxPartsPerRead only controls fanout when a logical read is larger than
	// RequestSizeBytes. A logical read that fits remains one wire request.
	MaxPartsPerRead int `key:"maxPartsPerRead" json:"max_parts_per_read"`
}

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

type ClientRequestType int

type Config struct {
	Enabled        bool                 `key:"enabled" json:"enabled"`
	Disk           DiskConfig           `key:"disk" json:"disk"`
	Memory         MemoryConfig         `key:"memory" json:"memory"`
	Coordinator    CoordinatorConfig    `key:"coordinator" json:"coordinator"`
	Server         ServerConfig         `key:"server" json:"server"`
	Client         ClientConfig         `key:"client" json:"client"`
	Global         GlobalConfig         `key:"global" json:"global"`
	Reconciliation ReconciliationConfig `key:"reconciliation" json:"reconciliation"`
}

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

type CoordinatorConfig struct {
	Token                    string `key:"token" json:"token"`
	RegistrationTTLSeconds   int    `key:"registrationTTLSeconds" json:"registration_ttl_seconds"`
	HeartbeatIntervalSeconds int    `key:"heartbeatIntervalSeconds" json:"heartbeat_interval_seconds"`
	HostWatchIntervalSeconds int    `key:"hostWatchIntervalSeconds" json:"host_watch_interval_seconds"`
}

type CoordinatorHost struct {
	// LogicalHostID is the stable cache routing identity. Multiple worker
	// process registrations can advertise addresses for the same logical host.
	LogicalHostID string
	// RegistrationID identifies one live worker/cache-server process lease.
	RegistrationID   string
	PoolName         string
	Locality         string
	NodeID           string
	CachePathID      string
	Addr             string
	PrivateAddr      string
	CapacityUsagePct float64
}

type CoordinatorRepository interface {
	SetCacheRegistration(ctx context.Context, host CoordinatorHost, ttl time.Duration) error
	GetActiveCacheRegistration(ctx context.Context, logicalHostID string) (registrationID string, found bool, err error)
	SetActiveCacheRegistration(ctx context.Context, logicalHostID, registrationID string, ttl time.Duration) error
	ListCacheLogicalHosts(ctx context.Context, poolName, locality string) ([]string, error)
	ListCacheRegistrations(ctx context.Context, logicalHostID string) ([]string, error)
	GetCacheRegistration(ctx context.Context, logicalHostID, registrationID string) (CoordinatorHost, bool, error)
	GetCacheLogicalHost(ctx context.Context, logicalHostID string) (CoordinatorHost, bool, error)
	RemoveCacheRegistration(ctx context.Context, logicalHostID, registrationID string) error
	CountCacheRegistrations(ctx context.Context, logicalHostID string) (int64, error)
	RemoveCacheLogicalHost(ctx context.Context, poolName, locality, logicalHostID string) error
}

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

type DiskConfig struct {
	Enabled      bool    `key:"enabled" json:"enabled"`
	HostPath     string  `key:"hostPath" json:"host_path"`
	MountPath    string  `key:"mountPath" json:"mount_path"`
	MaxUsagePct  float64 `key:"maxUsagePct" json:"max_usage_pct"`
	MinFreeBytes int64   `key:"minFreeBytes" json:"min_free_bytes"`
}

type DiskUsage struct {
	TotalBytes     uint64
	AvailableBytes uint64
	UsedBytes      uint64
	UsagePct       float64
}

type ErrNodeNotFound struct {
	Id string
}

type FSConfig 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 FSMetadata 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 FSNode struct {
	fs.Inode
	// contains filtered or unexported fields
}

type FSSystemOpts struct {
	Verbose       bool
	MetadataStore CacheMetadataStore
	Config        ClientConfig
	Client        *Client
}

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

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

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

type GlobalConfig struct {
	DefaultLocality                 string  `key:"defaultLocality" json:"default_locality"`
	ServerPort                      uint    `key:"serverPort" json:"server_port"`
	DiscoveryIntervalS              int     `key:"discoveryIntervalS" json:"discovery_interval_s"`
	DiscoveryJitterS                int     `key:"discoveryJitterS" json:"discovery_jitter_s"`
	MaxDiscoveryConcurrency         int     `key:"maxDiscoveryConcurrency" json:"max_discovery_concurrency"`
	HostMonitorIntervalS            int     `key:"hostMonitorIntervalS" json:"host_monitor_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"`
	GRPCPayloadCodecV2              bool    `key:"grpcPayloadCodecV2" json:"grpc_payload_codec_v2"`
	GRPCPayloadCodecMinBytes        int     `key:"grpcPayloadCodecMinBytes" json:"grpc_payload_codec_min_bytes"`
	DebugMode                       bool    `key:"debugMode" json:"debug_mode"`
	PrettyLogs                      bool    `key:"prettyLogs" json:"pretty_logs"`
}

type Host struct {
	RTT              time.Duration `redis:"rtt" json:"rtt"`
	HostId           string        `redis:"host_id" json:"host_id"`
	RegistrationID   string        `redis:"registration_id" json:"registration_id"`
	PoolName         string        `redis:"pool_name" json:"pool_name"`
	Locality         string        `redis:"locality" json:"locality"`
	NodeID           string        `redis:"node_id" json:"node_id"`
	CachePathID      string        `redis:"cache_path_id" json:"cache_path_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 HostDirectory interface {
	GetAvailableHosts(ctx context.Context, locality string) ([]*Host, error)
}

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 LocalContentSource struct {
	Path      string
	CachePath string
}

type MemoryConfig struct {
	Enabled     bool  `key:"enabled" json:"enabled"`
	MaxCachePct int64 `key:"maxCachePct" json:"max_cache_pct"`
}

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

type MetadataConfig struct {
	Mode         MetadataMode `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"`
	RedisInsecureSkipVerify bool      `key:"redisInsecureSkipVerify" json:"redis_insecure_skip_verify"`
	RedisMode               RedisMode `key:"redisMode" json:"redis_mode"`
	RedisMasterName         string    `key:"redisMasterName" json:"redis_master_name"`
}

type MetadataMode string

type MockCacheMetadataStore 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 OperationTrace struct {
	Operation     string                  `json:"operation,omitempty"`
	Result        string                  `json:"result,omitempty"`
	Hash          string                  `json:"hash,omitempty"`
	RoutingKey    string                  `json:"routing_key,omitempty"`
	Offset        int64                   `json:"offset,omitempty"`
	Length        int64                   `json:"length,omitempty"`
	Read          int64                   `json:"read,omitempty"`
	Bytes         int64                   `json:"bytes,omitempty"`
	ExpectedSize  int64                   `json:"expected_size,omitempty"`
	Views         int                     `json:"views,omitempty"`
	DurationUs    int64                   `json:"duration_us,omitempty"`
	HostRefreshes int                     `json:"host_refreshes,omitempty"`
	Attempts      []OperationTraceAttempt `json:"attempts,omitempty"`
}

type OperationTraceAttempt struct {
	HostIndex      int    `json:"host_index"`
	HostID         string `json:"host_id,omitempty"`
	RegistrationID string `json:"registration_id,omitempty"`
	PoolName       string `json:"pool_name,omitempty"`
	Locality       string `json:"locality,omitempty"`
	NodeID         string `json:"node_id,omitempty"`
	CachePathID    string `json:"cache_path_id,omitempty"`
	Addr           string `json:"addr,omitempty"`
	PrivateAddr    string `json:"private_addr,omitempty"`
	HasEndpoint    bool   `json:"has_endpoint"`
	Source         string `json:"source"`
	Result         string `json:"result"`
	Read           int64  `json:"read,omitempty"`
	Bytes          int64  `json:"bytes,omitempty"`
	ExpectedSize   int64  `json:"expected_size,omitempty"`
	ContentStatus  string `json:"content_status,omitempty"`
	ElapsedUs      int64  `json:"elapsed_us,omitempty"`
	Error          string `json:"error,omitempty"`
}

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

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

type ReadPrefetchConfig struct {
	Enabled         bool  `key:"enabled" json:"enabled"`
	AheadBytes      int64 `key:"aheadBytes" json:"ahead_bytes"`
	Workers         int   `key:"workers" json:"workers"`
	PartLengthBytes int64 `key:"partLengthBytes" json:"part_length_bytes"`
	MaxPartsPerRead int   `key:"maxPartsPerRead" json:"max_parts_per_read"`
}

type RecentStub struct {
	WorkspaceID string
	StubID      string
	LastSeen    time.Time
}

type ReconciliationConfig struct {
	Enabled               bool  `key:"enabled" json:"enabled"`
	IntervalSeconds       int   `key:"intervalSeconds" json:"interval_seconds"`
	RecentStubTTLSeconds  int   `key:"recentStubTTLSeconds" json:"recent_stub_ttl_seconds"`
	LockTTLSeconds        int   `key:"lockTTLSeconds" json:"lock_ttl_seconds"`
	MaxStubsPerCycle      int   `key:"maxStubsPerCycle" json:"max_stubs_per_cycle"`
	MaxItemsPerCycle      int   `key:"maxItemsPerCycle" json:"max_items_per_cycle"`
	VolumeMinBytes        int64 `key:"volumeMinBytes" json:"volume_min_bytes"`
	OriginFallbackEnabled bool  `key:"originFallbackEnabled" json:"origin_fallback_enabled"`
	// MaxDiskUsagePct is the soft pressure watermark (0-1). Above it, the
	// cache owner evicts lower-priority content and pauses proactive
	// reconciliation. Near it, reconciliation is limited to the ranked recent
	// working set so eviction and materialization do not churn.
	MaxDiskUsagePct float64 `key:"maxDiskUsagePct" json:"max_disk_usage_pct"`
}

type RedisCacheMetadataStore 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 RendezvousHasher interface {
	Add(hosts ...*Host)
	Remove(host *Host)
	GetN(n int, key string) []*Host
}

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

type S3ContentSource struct {
	Path           string
	CachePath      string
	BucketName     string
	Region         string
	EndpointURL    string
	AccessKey      string
	SecretKey      string
	ForcePathStyle bool
}

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

type Server struct {
	proto.UnimplementedCacheServer
	// contains filtered or unexported fields
}

type ServerConfig struct {
	DiskCacheDir         string  `key:"diskCacheDir" json:"disk_cache_dir"`
	DiskCacheMaxUsagePct float64 `key:"diskCacheMaxUsagePct" json:"disk_cache_max_usage_pct"`
	// DiskCacheEvictWatermarkPct is the filesystem usage fraction (0-1) above
	// which the store evicts least-recently-accessed content until usage
	// falls back below the watermark. It must sit below the kubelet's
	// DiskPressure thresholds so the node never reaches them. Defaults to 0.80.
	DiskCacheEvictWatermarkPct   float64                   `key:"diskCacheEvictWatermarkPct" json:"disk_cache_evict_watermark_pct"`
	ObjectTtlS                   int                       `key:"objectTtlS" json:"object_ttl_s"`
	MaxCachePct                  int64                     `key:"maxCachePct" json:"max_cache_pct"`
	PageSizeBytes                int64                     `key:"pageSizeBytes" json:"page_size_bytes"`
	PageFileBuckets              int                       `key:"pageFileBuckets" json:"page_file_buckets"`
	SmallRangeCopyThresholdBytes int64                     `key:"smallRangeCopyThresholdBytes" json:"small_range_copy_threshold_bytes"`
	ReadTransport                ServerReadTransportConfig `key:"readTransport" json:"read_transport"`
	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"`
}

type ServerOption func(*ServerOpts)

type ServerOpts struct {
	HostID        string
	MetadataStore CacheMetadataStore
	AdvertiseAddr string
}

type ServerReadTransportConfig struct {
	Enabled  bool `key:"enabled" json:"enabled"`
	Sendfile bool `key:"sendfile" json:"sendfile"`
	// MaxRequestSizeBytes is the raw-protocol cap and is independent of gRPC.
	MaxRequestSizeBytes int64 `key:"maxRequestSizeBytes" json:"max_request_size_bytes"`
	// MaxInflightBytes is a weighted server-wide admission budget.
	MaxInflightBytes int64 `key:"maxInflightBytes" json:"max_inflight_bytes"`
	// MaxConcurrentRequests also bounds requests with very small or empty ranges.
	MaxConcurrentRequests int `key:"maxConcurrentRequests" json:"max_concurrent_requests"`
}

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 Store struct {
	// contains filtered or unexported fields
}

type StoreContentOptions struct {
	RoutingKey string
	Lock       bool
}

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"`
}

type VolumeObjectIdentity struct {
	Scope    string
	Endpoint string
	Bucket   string
	Path     string
	ETag     string
	Size     uint64
}