rendercontext

func BuildResourcesValue ¶

func BuildResourcesValue(
	resourceStores map[string]stores.Store,
	typedTypes map[string]reflect.Type,
	watchedNames []string,
	indexByFor func(name string) []string,
	lazyFor func(name string) bool,
	apiVersionFor func(name string) string,
	logger *slog.Logger,
) any

BuildResourcesValue constructs the typed-struct `resources` runtime value the engine binds at template-run time. The shape matches typebootstrap.BuildEngineDeclarations exactly:

*struct{ <PascalCased-name> *innerStore; … }

with one field per watched resource. The inner store's List / Fetch / GetSingle closures return typed pointers when a generated type is available, untyped any otherwise — the OUTER struct shape stays the same either way, so the runtime value keeps binding cleanly against the engine declaration regardless of whether typebootstrap produced types for any given resource.

Production is fail-closed on typebootstrap failures (Bootstrap aborts iteration startup; helpers.BuildAdditionalDeclarations panics on nil Result), so every production engine declares the typed struct and this function always produces a typed value. There is no map fallback — callers that bypass the typed-engine path (a unit test constructing templating.New(...) directly without BuildAdditionalDeclarations) must build their own map[string]templating.ResourceStore aligned with the engine's default declaration in registerScriggoRuntimeVars; do not call BuildResourcesValue from that path.

Inputs:

• resourceStores: per-name stores.Store for the resources the local controller has live watchers for. Looked up by name; a watched-resource name with no entry gets a struct field whose closures collapse to empty results. Names in this map that are NOT in watchedNames are silently ignored (e.g. the auto- injected haproxy_pods store, which belongs in controller["haproxy_pods"], not `resources`).
• typedTypes: per-name generated reflect.Type from typebootstrap. Looked up by name; an unset entry yields an untyped-closure field for that resource. Names not in watchedNames are ignored.
• watchedNames: every watched-resource name from the config — SOLE iteration source. Must mirror what typebootstrap.BuildEngineDeclarations iterated when it built the engine-side declaration; any field-list drift trips Scriggo's "must have type assignable to struct {...}" bind- time panic.
• indexByFor: returns the per-resource IndexBy slice the watcher used to build the underlying store; forwarded to the StoreWrapper so per-render snapshot indices align with the live store state.
• lazyFor: returns whether the per-resource wrapper should use LazySnapshot mode. True when the WatchedResource config has `store: on-demand` (CachedStore-backed) — see StoreWrapper's LazySnapshot field documentation for the semantics. A nil callback or one that always returns false keeps the historical eager-snapshot behaviour for every resource.

func CapabilitiesToMap ¶

func CapabilitiesToMap(caps *dataplane.Capabilities) map[string]any

CapabilitiesToMap converts a Capabilities struct to a template-friendly map. The map uses snake_case keys matching the Capabilities struct field names (e.g., "supports_waf" for SupportsWAF) for consistency with template conventions.

func MergeAuxiliaryFiles ¶

func MergeAuxiliaryFiles(static, dynamic *dataplane.AuxiliaryFiles) *dataplane.AuxiliaryFiles

MergeAuxiliaryFiles merges two AuxiliaryFiles structures, with dynamic files appended to static files.

This is used to combine:

• Pre-declared templates (maps, files, certs from config)
• Dynamically registered files (via FileRegistry during rendering).

func MergeExtraContextInto ¶

func MergeExtraContextInto(renderCtx map[string]any, cfg *config.Config)

MergeExtraContextInto merges the extraContext variables from the config into the provided template context.

This allows templates to access custom variables directly (e.g., {{ debug.enabled }}) instead of wrapping them in a "config" object.

The extraContext key is always populated (with an empty map if nil) to prevent nil pointer dereferences in templates that use extraContext | dig("key") | fallback(default).

func PathResolverFromValidationPaths ¶

func PathResolverFromValidationPaths(vp *dataplane.ValidationPaths) *templating.PathResolver

PathResolverFromValidationPaths creates a PathResolver from ValidationPaths.

This is a convenience function for creating PathResolvers in contexts where ValidationPaths is available (testrunner, dryrunvalidator, benchmark). The TempDir from ValidationPaths becomes the BaseDir used with "default-path origin" in HAProxy's global section to resolve relative paths.

func SeparateHAProxyPodStore ¶

func SeparateHAProxyPodStore(storeMap map[string]stores.Store) (resourceStores map[string]stores.Store, haproxyPodStore stores.Store)

SeparateHAProxyPodStore separates the haproxy-pods store from resource stores.

This is needed because haproxy-pods goes in the controller namespace (controller.haproxy_pods), not in the resources namespace. This function extracts haproxy-pods and returns both the filtered resource stores and the haproxy pod store separately.

Returns:

• resourceStores: All stores except haproxy-pods
• haproxyPodStore: The haproxy-pods store, or nil if not present

func SortSnippetNames ¶

func SortSnippetNames(snippets map[string]config.TemplateSnippet) []string

SortSnippetNames sorts template snippet names alphabetically. Returns a slice of snippet names in sorted order.

Snippet ordering is controlled by encoding priority in the snippet name (e.g., "features-050-ssl" for priority 50). This is required because render_glob sorts templates alphabetically.