compute

package
v0.0.391 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Aug 16, 2024 License: Apache-2.0 Imports: 31 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var (
	// Configurable globally only for now.
	CachingEnabled = true
	// If enabled, does not use cached contents, but still verifies that if we do have
	// cached contents, they match what we produced.
	VerifyCaching = false
)
View Source 
var ErrDoneSinking = errors.New("done sinking")

ErrDoneSinking is used as a return value from Updated to indicate that no more action will be taken and Sink() should return. It is not returned as an error by any function.

View Source 
var ExplainIndentValues = false

Functions

func AttachOrch 

func AttachOrch(parent context.Context, orch *Orch) context.Context

func Cache 

func Cache(ctx context.Context) cache.Cache

func Continuously 

func Continuously(baseCtx context.Context, sinkable Sinkable, transformErr TransformErrorFunc) error

Continuously computes `sinkable` and recomputes it on any tansitive change to `sinkable`'s inputs.

`transformErr` (if not nil) allows to transform (e.g. ignore) encountered errors.

func Do 

func Do(parent context.Context, do func(context.Context) error) error

func DoWithCache added in v0.0.92 

func DoWithCache(parent context.Context, cache cache.Cache, do func(context.Context) error) error

func Explain 

func Explain(ctx context.Context, w io.Writer, c UntypedComputable) error

func GetValue 

func GetValue[V any](ctx context.Context, c Computable[V]) (V, error)

func IsPrecomputed 

func IsPrecomputed[V any](c Computable[V]) (V, bool)

func MustGetDepValue 

func MustGetDepValue[V any](deps Resolved, c Computable[V], key string) V

func RegisterBytesCacheable 

func RegisterBytesCacheable()

func RegisterCacheable 

func RegisterCacheable[V any](c Cacheable[V])

func RegisterProtoCacheable 

func RegisterProtoCacheable()

func SpawnCancelableOnContinuously 

func SpawnCancelableOnContinuously(ctx context.Context, f func(context.Context) error) func()

func Stop 

func Stop(ctx context.Context, err error)

func Unwrap 

func Unwrap(c any) (any, bool)

func WithGraphLifecycle 

func WithGraphLifecycle[V any](ctx context.Context, f func(context.Context) (V, error)) (V, error)

func WithLock added in v0.0.376 

func WithLock[T any](ctx context.Context, key string, make func(context.Context) (T, error)) (T, error)

Types

type ByteStreamWriter 

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

func NewByteStream 

func NewByteStream(ctx context.Context) (*ByteStreamWriter, error)

func (*ByteStreamWriter) Close 

func (bsw *ByteStreamWriter) Close() error

func (*ByteStreamWriter) Complete 

func (bsw *ByteStreamWriter) Complete() (bytestream.ByteStream, error)

func (*ByteStreamWriter) Write 

func (bsw *ByteStreamWriter) Write(p []byte) (int, error)

type Cacheable 

type Cacheable[V any] interface {
	Digester
	LoadCached(context.Context, cache.Cache, CacheableInstance, schema.Digest) (Result[V], error)
	Cache(context.Context, cache.Cache, V) (schema.Digest, error)
}

type CacheableInstance 

type CacheableInstance interface {
	NewInstance() interface{}
}

type Computable 

type Computable[V any] interface {
	Action() *tasks.ActionEvent
	Inputs() *In
	Output() Output // Optional.
	Compute(context.Context, Resolved) (V, error)

	UntypedComputable
}

A computable represents a node in a computation graph. Each computation node produces a value, which is computed by its `Compute` method. A node's output can be cached, and is keyed by all declared inputs. For correctness, it is required that all meaningful inputs that may impact the semantics of the output (and its digest), be listed in `Inputs`. A node can also depend on other nodes, and use their computed values. That relationship is established by declaring another Computable as an Input to this one. The resulting value, will then be available in `Resolved`. If any of node's dependencies fails to compute, the node implicitly fails as well (with the same error).

func Collect 

func Collect[V any](ev *tasks.ActionEvent, computables ...Computable[V]) Computable[[]ResultWithTimestamp[V]]

func Consume 

func Consume[V any](action *tasks.ActionEvent, from Computable[V], compute func(context.Context, ResultWithTimestamp[V]) error) Computable[V]

Consume ensures that the specified method is called on the value when it is computed, and before other computables that depend on the return value of Consume.

func Error 

func Error[V any](err error) Computable[V]

func Inline added in v0.0.109 

func Inline[To any](action *tasks.ActionEvent, compute func(context.Context) (To, error)) Computable[To]

func Map 

func Map[V any](action *tasks.ActionEvent, inputs *In, output Output,
	compute func(context.Context, Resolved) (V, error)) Computable[V]

func Merge added in v0.0.117 

func Merge[V any](desc string, c Computable[[]ResultWithTimestamp[[]V]]) Computable[[]V]

func Named 

func Named[V any](action *tasks.ActionEvent, c Computable[V]) Computable[V]

func Precomputed 

func Precomputed[V any](v V, computeDigest func(context.Context, V) (schema.Digest, error)) Computable[V]

func Sticky 

func Sticky[V any](action *tasks.ActionEvent, c Computable[V]) Computable[V]

func Transform 

func Transform[From, To any](desc string, from Computable[From], compute func(context.Context, From) (To, error)) Computable[To]

type ComputeDigestFunc 

type ComputeDigestFunc func(context.Context, any) (schema.Digest, error)

type Detach 

type Detach struct {
	Action *tasks.ActionEvent
	Do     func(context.Context) error
}

type DigestFunc 

type DigestFunc func(context.Context) (schema.Digest, error)

func (DigestFunc) ComputeDigest 

func (f DigestFunc) ComputeDigest(ctx context.Context) (schema.Digest, error)

type Digester 

type Digester interface {
	ComputeDigest(context.Context, any) (schema.Digest, error)
}

type Digestible 

type Digestible interface {
	ComputeDigest(context.Context) (schema.Digest, error)
}

type DoScoped 

type DoScoped[V any] struct{}

A Computable whose lifecycle is bound to the surrounding Do() invocation. If the Computable is attempted to be computed outside a Do()-bound context, the program panics. A Do()-scoped Computable _must_ have deterministic inputs, so that a key can be calculated. This type of Computable is useful when different parts of the program want to share a computation that depends strictly on the inputs.

func (DoScoped[V]) Output 

func (c DoScoped[V]) Output() Output

type Future 

type Future[V any] struct {
	// contains filtered or unexported fields
}

func (*Future[V]) Wait 

func (f *Future[V]) Wait(ctx context.Context) (ResultWithTimestamp[V], error)

type In 

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

func Inputs 

func Inputs() *In

func (*In) Bool 

func (in *In) Bool(key string, v bool) *In

func (*In) Computable 

func (in *In) Computable(key string, c UntypedComputable) *In

func (*In) Digest 

func (in *In) Digest(key string, d Digestible) *In

func (*In) Indigestible 

func (in *In) Indigestible(key string, value interface{}) *In

An unusable input (marking the corresponding Computable having non-computable inputs). We accept a variable to help with code search; but it is otherwise unused.

func (*In) JSON 

func (in *In) JSON(key string, json interface{}) *In

func (*In) Marshal 

func (in *In) Marshal(key string, marshaller func(context.Context, io.Writer) error) *In

func (*In) NonCacheable added in v0.0.109 

func (in *In) NonCacheable() *In

func (*In) Proto 

func (in *In) Proto(key string, msg proto.Message) *In

func (*In) Str 

func (in *In) Str(key string, str string) *In

func (*In) StrMap 

func (in *In) StrMap(key string, m map[string]string) *In

func (*In) Stringer 

func (in *In) Stringer(key string, str fmt.Stringer) *In

func (*In) Strs 

func (in *In) Strs(key string, strs []string) *In

type LocalScoped 

type LocalScoped[V any] struct {
	// contains filtered or unexported fields
}

A Computable whose lifecycle is bound to the environment where it is computed. This is the most common option, as it yields for the clearest cancellation semantics and instance-level sharing as expected in Go. A "LocalScoped" Computable embeds a Promise which keeps track of the computation state of the Computable.

func (*LocalScoped[V]) Output 

func (c *LocalScoped[V]) Output() Output

type ObserveNote added in v0.0.109 

type ObserveNote string
const (
	ObserveContinuing ObserveNote = "observe.continuing"
	ObserveDone       ObserveNote = "observe.done"
)

type Orch 

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

func On 

func On(ctx context.Context) *Orch

func (*Orch) BestEffort added in v0.0.164 

func (g *Orch) BestEffort(ev *tasks.ActionEvent, do func(context.Context) error)

func (*Orch) Call 

func (g *Orch) Call(callback func(context.Context) error) error

func (*Orch) Cleanup 

func (g *Orch) Cleanup(ev *tasks.ActionEvent, f func(context.Context) error)

func (*Orch) Detach 

func (g *Orch) Detach(ev *tasks.ActionEvent, f func(context.Context) error)

func (*Orch) DetachWith 

func (g *Orch) DetachWith(d Detach)

type Output 

type Output struct {
	NonDeterministic bool
	NotCacheable     bool
}

func (Output) CanCache 

func (o Output) CanCache() bool

func (Output) DontCache 

func (o Output) DontCache() Output

type PrecomputeScoped 

type PrecomputeScoped[V any] struct{}

This Computable embeds a "precomputed" value and Compute() is guaranteed to return immediately.

func (PrecomputeScoped[V]) Output 

func (c PrecomputeScoped[V]) Output() Output

type Promise 

type Promise[V any] struct {
	// contains filtered or unexported fields
}

func ErrPromise 

func ErrPromise[V any](err error) *Promise[V]

func NewPromise 

func NewPromise[V any](g *Orch, action *tasks.ActionEvent, callback func(context.Context) (ResultWithTimestamp[V], error)) *Promise[V]

func (*Promise[V]) Future 

func (f *Promise[V]) Future() *Future[V]

type Resolved 

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

type Result 

type Result[V any] struct {
	Digest           schema.Digest
	NonDeterministic bool
	Value            V
}

func NoResult 

func NoResult[V any]() (Result[V], error)

func (Result[V]) HasDigest 

func (r Result[V]) HasDigest() bool

type ResultWithTimestamp 

type ResultWithTimestamp[V any] struct {
	Result[V]
	Set       bool
	Cached    bool
	ActionID  tasks.ActionID
	Started   time.Time
	Completed time.Time // When this value was computed (if known).
	// contains filtered or unexported fields
}

func Get 

func Get[V any](ctx context.Context, c Computable[V]) (ResultWithTimestamp[V], error)

func GetDep 

func GetDep[V any](deps Resolved, c Computable[V], key string) (ResultWithTimestamp[V], bool)

func GetDepWithType 

func GetDepWithType[V any](deps Resolved, key string) (ResultWithTimestamp[V], bool)

type Sinkable 

type Sinkable interface {
	Inputs() *In
	Updated(context.Context, Resolved) error
	Cleanup(context.Context) error
}

type TransformErrorFunc 

type TransformErrorFunc func(error) error

type UntypedComputable added in v0.0.109 

type UntypedComputable interface {
	Action() *tasks.ActionEvent
	Inputs() *In
	Output() Output // Optional.
	// contains filtered or unexported methods
}

type Versioned 

type Versioned interface {
	Observe(context.Context, func(ResultWithTimestamp[any], ObserveNote)) (func(), error)
}

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.