solver

type Builder interface {
	Build(ctx context.Context, e Edge) (CachedResult, error)
	Context(ctx context.Context) context.Context
	EachValue(ctx context.Context, key string, fn func(interface{}) error) error
}

type CacheExportMode int

type CacheExportOpt struct {
	// Convert can convert a build result to transferable object
	Convert func(context.Context, Result) (*Remote, error)
	// Mode defines a cache export algorithm
	Mode CacheExportMode
}

type CacheExporter interface {
	ExportTo(ctx context.Context, t CacheExporterTarget, opt CacheExportOpt) ([]CacheExporterRecord, error)
}

type CacheExporterRecord interface {
	AddResult(createdAt time.Time, result *Remote)
	LinkFrom(src CacheExporterRecord, index int, selector string)
}

type CacheExporterTarget interface {
	Add(dgst digest.Digest) CacheExporterRecord
	Visit(interface{})
	Visited(interface{}) bool
}

type CacheID string

type CacheInfoLink struct {
	Input    Index         `json:"Input,omitempty"`
	Output   Index         `json:"Output,omitempty"`
	Digest   digest.Digest `json:"Digest,omitempty"`
	Selector digest.Digest `json:"Selector,omitempty"`
}

type CacheKey struct {
	ID string
	// contains filtered or unexported fields
}

type CacheKeyStorage interface {
	Exists(id string) bool
	Walk(fn func(id string) error) error

	WalkResults(id string, fn func(CacheResult) error) error
	Load(id string, resultID string) (CacheResult, error)
	AddResult(id string, res CacheResult) error
	Release(resultID string) error
	WalkIDsByResult(resultID string, fn func(string) error) error

	AddLink(id string, link CacheInfoLink, target string) error
	WalkLinks(id string, link CacheInfoLink, fn func(id string) error) error
	HasLink(id string, link CacheInfoLink, target string) bool
	WalkBacklinks(id string, fn func(id string, link CacheInfoLink) error) error
}

type CacheKeyWithSelector struct {
	Selector digest.Digest
	CacheKey ExportableCacheKey
}

type CacheLink struct {
	Source   digest.Digest `json:",omitempty"`
	Input    Index         `json:",omitempty"`
	Output   Index         `json:",omitempty"`
	Base     digest.Digest `json:",omitempty"`
	Selector digest.Digest `json:",omitempty"`
}

type CacheManager interface {
	// ID is used to identify cache providers that are backed by same source
	// to avoid duplicate calls to the same provider
	ID() string
	// Query searches for cache paths from one cache key to the output of a
	// possible match.
	Query(inp []CacheKeyWithSelector, inputIndex Index, dgst digest.Digest, outputIndex Index) ([]*CacheKey, error)
	Records(ck *CacheKey) ([]*CacheRecord, error)
	// Load pulls and returns the cached result
	Load(ctx context.Context, rec *CacheRecord) (Result, error)
	// Save saves a result based on a cache key
	Save(key *CacheKey, s Result) (*ExportableCacheKey, error)
}

type CacheMap struct {
	// Digest is a base digest for operation that needs to be combined with
	// inputs cache or selectors for dependencies.
	Digest digest.Digest
	Deps   []struct {
		// Optional digest that is merged with the cache key of the input
		Selector digest.Digest
		// Optional function that returns a digest for the input based on its
		// return value
		ComputeDigestFunc ResultBasedCacheFunc
	}
}

type CacheRecord struct {
	ID        string
	Size      int
	CreatedAt time.Time
	Priority  int
	// contains filtered or unexported fields
}

type CacheResult struct {
	CreatedAt time.Time
	ID        string
}

type CacheResultStorage interface {
	Save(Result) (CacheResult, error)
	Load(ctx context.Context, res CacheResult) (Result, error)
	LoadRemote(ctx context.Context, res CacheResult) (*Remote, error)
	Exists(id string) bool
}

type CachedResult interface {
	Result
	CacheKeys() []ExportableCacheKey
}

type Edge struct {
	Index  Index
	Vertex Vertex
}

type ExportableCacheKey struct {
	*CacheKey
	Exporter CacheExporter
}

type Index int

type Job struct {
	SessionID string
	// contains filtered or unexported fields
}

type Op interface {
	// CacheMap returns structure describing how the operation is cached.
	// Currently only roots are allowed to return multiple cache maps per op.
	CacheMap(context.Context, int) (*CacheMap, bool, error)
	// Exec runs an operation given results from previous operations.
	Exec(ctx context.Context, inputs []Result) (outputs []Result, err error)
}

type Remote struct {
	Descriptors []ocispec.Descriptor
	Provider    content.Provider
}

type ResolveOpFunc func(Vertex, Builder) (Op, error)

type Result interface {
	ID() string
	Release(context.Context) error
	Sys() interface{}
}

type ResultBasedCacheFunc func(context.Context, Result) (digest.Digest, error)

type SharedCachedResult struct {
	*SharedResult
	CachedResult
}

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

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

type SolverOpt struct {
	ResolveOpFunc ResolveOpFunc
	DefaultCache  CacheManager
}

type Vertex interface {
	// Digest is a content-addressable vertex identifier
	Digest() digest.Digest
	// Sys returns an internal value that is used to execute the vertex. Usually
	// this is capured by the operation resolver method during solve.
	Sys() interface{}
	Options() VertexOptions
	// Array of edges current vertex depends on.
	Inputs() []Edge
	Name() string
}

type VertexOptions struct {
	IgnoreCache  bool
	CacheSources []CacheManager
	Description  map[string]string // text values with no special meaning for solver
	ExportCache  *bool
}