cache

type CacheKey struct {
	ID      string
	Results []Result
}

type Config struct {
	ImportPeriod  time.Duration
	ExportPeriod  time.Duration
	ExportTimeout time.Duration
}

type ExportRecord struct {
	Digest     digest.Digest // record digest
	CacheRefID string        // worker cache id
}

type GetCacheMountConfigRequest struct{}

type GetCacheMountConfigResponse struct {
	SyncedCacheMounts []SyncedCacheMountConfig
}

type GetCacheMountUploadURLRequest struct {
	CacheName string
	Digest    digest.Digest
	Size      int64
}

type GetCacheMountUploadURLResponse struct {
	URL     string
	Headers map[string]string
}

type GetConfigRequest struct {
	EngineID string
}

type GetLayerDownloadURLRequest struct {
	Digest digest.Digest
}

type GetLayerDownloadURLResponse struct {
	URL string
}

type GetLayerUploadURLRequest struct {
	Digest digest.Digest
}

type GetLayerUploadURLResponse struct {
	URL     string
	Headers map[string]string
	Skip    bool
}

type Link struct {
	ID       string
	LinkedID string
	Input    int
	Digest   digest.Digest
	Selector digest.Digest
}

type Manager interface {
	solver.CacheManager
	StartCacheMountSynchronization(context.Context) error
	ReleaseUnreferenced(context.Context) error
	Close(context.Context) error
}

type ManagerConfig struct {
	KeyStore     solver.CacheKeyStorage
	ResultStore  solver.CacheResultStorage
	Worker       worker.Worker
	MountManager *mounts.MountManager
	ServiceURL   string
	Token        string
	EngineID     string
}

type RecordLayers struct {
	RecordDigest digest.Digest
	Layers       []ocispecs.Descriptor
}

type Result struct {
	ID          string
	CreatedAt   time.Time
	Description string
}

type Service interface {
	// GetConfig returns configuration needed for the engine to push layer blobs
	GetConfig(context.Context, GetConfigRequest) (*Config, error)

	// UpdateCacheRecords informs the cache service of the current state of the cache metadata.
	// It returns a list of cache refs that should be prepared for export and pushed.
	UpdateCacheRecords(context.Context, UpdateCacheRecordsRequest) (*UpdateCacheRecordsResponse, error)

	// UpdateCacheLayers tells the cache service that layers for the given records have been
	// uploaded with the given digests.
	UpdateCacheLayers(context.Context, UpdateCacheLayersRequest) error

	// ImportCache returns a cache config that the engine can turn into cache manager.
	ImportCache(context.Context) (*remotecache.CacheConfig, error)

	// GetLayerDownloadURL returns a URL that the engine can use to download the layer blob. The URL
	// is only valid for a limited time so this API should only be called right as the layer is needed.
	GetLayerDownloadURL(context.Context, GetLayerDownloadURLRequest) (*GetLayerDownloadURLResponse, error)

	// GetLayerUploadURL returns a URL that the engine can use to upload the layer blob. The URL is only
	// valid for a limited time so this API should only be called right as the layer is to be uploaded.
	GetLayerUploadURL(context.Context, GetLayerUploadURLRequest) (*GetLayerUploadURLResponse, error)

	// GetCacheMountConfig returns a list of cache mounts that the engine should sync locally. It contains
	// metadata like digest+size plus a time-limited URL that the engine can use to download the cache mounts.
	GetCacheMountConfig(context.Context, GetCacheMountConfigRequest) (*GetCacheMountConfigResponse, error)

	// GetCacheMountUploadURL returns a URL that the engine can use to upload the cache mount blob. The URL is only
	// valid for a limited time so this API should only be called right as the cache mount is to be uploaded.
	GetCacheMountUploadURL(context.Context, GetCacheMountUploadURLRequest) (*GetCacheMountUploadURLResponse, error)
}

type SyncedCacheMountConfig struct {
	Name      string
	Digest    digest.Digest
	Size      int64
	MediaType string
	URL       string
}

type UpdateCacheLayersRequest struct {
	UpdatedRecords []RecordLayers
}

type UpdateCacheRecordsRequest struct {
	CacheKeys []CacheKey
	Links     []Link
}

type UpdateCacheRecordsResponse struct {
	// cache records that the engine should prepare layers for and push
	ExportRecords []ExportRecord
}