component

Overview ¶

Package component provides shared bundler utilities used by pkg/bundler and its deployers.

Component configuration is defined declaratively in recipes/registry.yaml. This package provides reusable building blocks for bundle generation. With the declarative registry, no separate Go packages are required per component — adding a registry.yaml entry is sufficient.

Historically AICR had one Go bundler package per component. Those per-component packages have been replaced by the registry-driven pkg/bundler.DefaultBundler; the legacy BaseBundler / MakeBundle entry points described below remain exported for external integrations and the component test harness.

Generic Bundler Framework ¶

The framework provides a declarative approach to bundle generation using:

ComponentConfig: Defines all component-specific settings in one struct:

• Name and DisplayName for identification
• ValueOverrideKeys for CLI --set flag mapping
• Node selector and toleration paths for workload placement
• DefaultHelmRepository, DefaultHelmChart, DefaultHelmChartVersion for Helm deployment
• TemplateGetter function for embedded templates
• Optional CustomManifestFunc for generating additional manifests
• Optional MetadataExtensions map for custom README template data (preferred over MetadataFunc)

MakeBundle: Generic function that handles all common bundling steps:

• Extracting component values from recipe input
• Applying user value overrides from CLI flags
• Applying node selectors and tolerations to Helm paths
• Creating directory structure
• Writing values.yaml with proper YAML headers
• Calling optional CustomManifestFunc for additional files
• Generating README from templates
• Computing checksums

Minimal Bundler Example ¶

Most bundlers can be implemented in ~50 lines using the framework:

var componentConfig = component.ComponentConfig{
    Name:                  "my-operator",
    DisplayName:           "My Operator",
    ValueOverrideKeys:     []string{"myoperator"},
    DefaultHelmRepository: "https://charts.example.com",
    DefaultHelmChart:      "example/my-operator",
    TemplateGetter:        GetTemplate,
}

type Bundler struct {
    *component.BaseBundler
}

func NewBundler(cfg *config.Config) *Bundler {
    return &Bundler{
        BaseBundler: component.NewBaseBundler(cfg, types.BundleTypeMyOperator),
    }
}

func (b *Bundler) Make(ctx context.Context, input recipe.RecipeInput, dir string, provider recipe.DataProvider) (*result.Result, error) {
    return component.MakeBundle(ctx, b.BaseBundler, input, dir, componentConfig, provider)
}

Custom Metadata ¶

Components that need additional template data beyond the default BundleMetadata can provide a MetadataExtensions map in ComponentConfig:

var componentConfig = component.ComponentConfig{
    // ... other fields ...
    MetadataExtensions: map[string]any{
        "InstallCRDs":   true,
        "CustomField":   "custom-value",
    },
}

These extensions are merged into the BundleMetadata.Extensions map and can be accessed in templates via {{ .Script.Extensions.InstallCRDs }}.

For more complex metadata requirements, MetadataFunc is still supported but MetadataExtensions is preferred for simple key-value additions.

Custom Manifest Generation ¶

Components that need to generate additional manifests can provide a CustomManifestFunc:

var componentConfig = component.ComponentConfig{
    // ... other fields ...
    CustomManifestFunc: func(ctx context.Context, b *component.BaseBundler,
        values map[string]any, configMap map[string]string, dir string) ([]string, error) {
        // Generate manifests using b.WriteFile() or b.GenerateFileFromTemplate()
        return []string{"manifests/custom.yaml"}, nil
    },
}

BaseBundler Helper Methods ¶

BaseBundler provides common functionality for file operations:

• CreateBundleDir: Creates directory structure with proper permissions
• WriteFile: Writes content with automatic directory creation
• WriteFileString: Convenience wrapper for string content
• RenderTemplate: Renders Go templates with error handling
• GenerateFileFromTemplate: One-step template rendering and file writing
• GenerateChecksums: Creates checksums.txt with SHA256 hashes
• CheckContext: Periodic context cancellation checking
• Finalize: Records timing and result metadata
• BuildConfigMapFromInput: Creates baseline config map from recipe input

Helper Functions ¶

Utility functions for common operations:

• GetConfigValue: Safely extracts config map values with defaults
• GetBundlerVersion: Returns bundler version from config
• GetRecipeBundlerVersion: Returns recipe version from config
• MarshalYAMLWithHeader: Serializes values with component header
• ApplyMapOverrides: Applies dot-notation overrides to nested maps
• ApplyNodeSelectorOverrides: Applies node selectors to Helm paths
• ApplyTolerationsOverrides: Applies tolerations to Helm paths
• GenerateDefaultBundleMetadata: Creates default BundleMetadata struct

Default BundleMetadata ¶

Components using the default metadata get:

• Namespace, HelmRepository, HelmChart, HelmChartVersion
• Version (bundler version), RecipeVersion

Access in templates via {{ .Script.Namespace }}, {{ .Script.Version }}, etc.

Internal Test Harness ¶

A TestHarness and RecipeBuilder live in this package's _test.go files for reuse by the package's own tests. They are intentionally not exported as production API — bundler tests in other packages should construct their own fixtures rather than depend on this package's test scaffolding.