eval

type Block ¶

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

Block is a Puppet lambda captured with its defining scope, invocable by a Function during iteration.

func (b *Block) Arity() int

func (b *Block) Call(args ...Value) (Value, error)

type Context ¶

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

Context is handed to every Function. It exposes the evaluator services a function needs without widening the public surface.

func (c *Context) Catalog() *catalog.Catalog

func (c *Context) Log(level, msg string)

func (c *Context) Lookup(key string) (Value, bool, error)

type ERBRenderer ¶

type ERBRenderer interface {
	RenderERB(src string, vars map[string]any) (string, error)
}

ERBRenderer renders an ERB template (the legacy Ruby-based template format used by template()/inline_template()). ERB templates may contain arbitrary Ruby, which a pure-Go evaluator cannot execute; a host that embeds a Ruby runtime (e.g. go-ruby-puppet/rbgo, which can reuse github.com/go-ruby-erb to compile the template to Ruby and then run it) wires an implementation via WithERBRenderer.

src is the raw template text. vars is the set of top-scope variables and facts the template may reference (as @instance variables / scope lookups in Ruby ERB). The result is the rendered string.

type Error ¶

type Error struct {
	Pos ast.Position
	Msg string
}

Error is an evaluation error, optionally carrying a source position.

func (e *Error) Error() string

type Evaluator ¶

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

Evaluator holds the state of one compilation.

func New(opts ...Option) *Evaluator

func (e *Evaluator) EvalPlan(name string, params map[string]any) (Value, error)

func (e *Evaluator) EvalProgram(prog *ast.Program) (*catalog.Catalog, error)

func (e *Evaluator) Logs() []LogEntry

func (e *Evaluator) RegisterFunction(name string, fn Function)

type ExportedStore ¶

type ExportedStore interface {
	StoreExported(node string, r *catalog.Resource) error
	CollectExported(capType, excludeNode string) ([]*catalog.Resource, error)
}

ExportedStore is the storeback seam for exported resources (`@@`). A host wires a real backend (e.g. PuppetDB via github.com/go-puppetdb/puppetdb) so that resources exported by one node's compilation can be collected by another node with `Type <<| query |>>`.

StoreExported is called for every `@@` resource declared during compilation. CollectExported returns the exported resources of the given capitalized type (e.g. "Sshkey"), excluding those exported by excludeNode (a node never collects its own exports). Query filtering is applied by the evaluator, so an implementation may return a superset.

type FactsProvider ¶

type FactsProvider interface {
	Fact(name string) (Value, bool)
	Facts() map[string]any
}

FactsProvider supplies top-scope facts. A bare fact name ("os") or a dotted path ("os.family") resolves through Fact; Facts returns the whole tree for `$facts`.

func FacterFacts() FactsProvider

type Function ¶

type Function func(c *Context, args []Value, block *Block) (Value, error)

Function is a callable contributed to the evaluator. args are the already evaluated positional arguments; block is the optional trailing lambda (nil when absent).

type LogEntry ¶

type LogEntry struct {
	Level   string
	Message string
}

LogEntry is one message emitted by a logging function (notice/info/…).

func EvalString(src string, opts ...Option) (*catalog.Catalog, []LogEntry, error)

type MapFacts ¶

type MapFacts map[string]any

MapFacts is a deterministic FactsProvider backed by a nested map. A dotted fact name digs through nested map[string]any / []any values, so {"os": {"family": "Debian"}} resolves "os.family".

func (m MapFacts) Fact(name string) (Value, bool)

func (m MapFacts) Facts() map[string]any

type MemoryExportedStore ¶

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

MemoryExportedStore is an in-memory ExportedStore. It is safe for concurrent use and is the default backend used in tests and single-process runs.

func NewMemoryExportedStore() *MemoryExportedStore

func (m *MemoryExportedStore) CollectExported(capType, excludeNode string) ([]*catalog.Resource, error)

func (m *MemoryExportedStore) StoreExported(node string, r *catalog.Resource) error

type Option ¶

type Option func(*Evaluator)

Option configures a new Evaluator.

func WithERBRenderer(r ERBRenderer) Option

func WithExportedStore(store ExportedStore) Option

func WithFacts(f FactsProvider) Option

func WithHiera(h *hiera.Hiera) Option

func WithNodeName(name string) Option

func WithPlanExecutor(x PlanExecutor) Option

func WithTemplateLoader(l TemplateLoader) Option

type PlanExecutor ¶

type PlanExecutor interface {
	RunTask(task string, targets []string, params map[string]any) (Value, error)
	RunCommand(command string, targets []string) (Value, error)
	RunScript(script string, targets []string, args []any) (Value, error)
	GetTargets(spec Value) (Value, error)
	ApplyCatalog(targets []string, cat *catalog.Catalog) (Value, error)
}

PlanExecutor is the orchestration seam a Bolt-like host (notably github.com/go-puppet-bolt/bolt) wires so that a `plan` written in the Puppet language can run tasks/commands/scripts and apply catalogs against targets.

Values use the evaluator's generic model (strings, []any, map[string]any) so the interface has no dependency on a specific transport package. Targets are passed as their string specs; an executor resolves them through its own inventory. The returned Value becomes the plan function's result (typically a ResultSet rendered as an Array of per-target result Hashes).

type ResourceRef ¶

type ResourceRef struct {
	Type  string
	Title string
}

ResourceRef is a Puppet resource reference value, e.g. `File['/tmp/x']`.

func (r *ResourceRef) String() string

type Scope ¶

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

Scope is a Puppet variable scope: a set of `$name => value` bindings with a lexical parent chain up to the top scope. Puppet variables are immutable once set within a scope.

type Sensitive ¶

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

Sensitive is the value-model wrapper for Puppet's Sensitive data type. It carries an arbitrary value while redacting it in every rendered form (to_s, inspect, interpolation) so secrets do not leak into logs or catalogs. The wrapped value is retrievable only through Sensitive.Unwrap (or the `unwrap` function). It is used by resource-api sensitive-parameter handling and by stdlib::rewrap_sensitive_data.

func NewSensitive(v Value) *Sensitive

func (s *Sensitive) String() string

func (s *Sensitive) Unwrap() Value

type TemplateLoader ¶

type TemplateLoader interface {
	Load(name string) (string, error)
}

TemplateLoader resolves an EPP/ERB template reference (e.g. "apache/vhost.epp") to its raw source text. Wire one via WithTemplateLoader so epp()/template() can load files. Without a loader, only the inline_* forms work.

type Value ¶

type Value = any

Value is a Puppet value. It uses the same representation as github.com/go-pcore/pcore: bool, int64, float64 and string for scalars, []any for arrays, map[string]any for hashes, pcore.Undef for undef, the pcore wrapper types for the rich values, and pcore.Type for data types.