stores

type CompositeStore ¶

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

CompositeStore wraps a base store with an overlay, providing a unified view that reflects both the actual state and proposed changes.

Read operations (Get, List) return the merged view. Write operations are not supported and will return an error.

Thread Safety ¶

CompositeStore itself is not thread-safe, but this is by design:

• A new CompositeStore is created for each validation request (not shared across goroutines)
• The base store must be thread-safe (k8s.Store uses sync.RWMutex internally)
• The overlay must not be modified after construction (immutable during validation)

This design avoids synchronization overhead since each request gets its own instance.

func NewCompositeStore(base Store, overlay *StoreOverlay) *CompositeStore

func (s *CompositeStore) Add(_ any, _ []string) error

func (s *CompositeStore) Clear() error

func (s *CompositeStore) Delete(_ ...string) error

func (s *CompositeStore) Get(keys ...string) ([]any, error)

func (s *CompositeStore) List() ([]any, error)

func (s *CompositeStore) Update(_ any, _ []string) error

type ContentOverlay ¶

type ContentOverlay interface {
	// IsEmpty returns true if the overlay contains no pending changes.
	IsEmpty() bool
}

ContentOverlay is a marker interface for overlay types.

Both K8s overlays (StoreOverlay) and HTTP overlays implement this interface, enabling unified handling in validation pipelines.

type HTTPContentOverlay ¶

type HTTPContentOverlay interface {
	ContentOverlay

	// GetContent returns content for the given URL.
	// Returns pending content if available, otherwise accepted content.
	GetContent(url string) (string, bool)

	// PendingURLs returns the list of URLs with pending content.
	PendingURLs() []string

	// HasPendingURL returns true if the given URL has pending content.
	HasPendingURL(url string) bool
}

HTTPContentOverlay represents HTTP content changes awaiting validation.

This interface abstracts the HTTP overlay to avoid circular imports between pkg/stores and pkg/httpstore. The httpstore.HTTPOverlay type implements this.

type OverlayStoreProvider ¶

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

OverlayStoreProvider applies ValidationContext overlays to a base provider.

In addition to applying K8s overlays, this provider also exposes the HTTP overlay for use by the render service.

Usage:

ctx := NewValidationContext(k8sOverlays).WithHTTPOverlay(httpOverlay)
provider := NewOverlayStoreProvider(baseProvider, ctx)

// K8s stores automatically have overlays applied
store := provider.GetStore("ingress")  // Returns CompositeStore if overlay exists

// HTTP overlay is accessible for render service
httpOverlay := provider.GetHTTPOverlay()  // Returns HTTPContentOverlay

func NewOverlayStoreProvider(base StoreProvider, context *ValidationContext) *OverlayStoreProvider

func (p *OverlayStoreProvider) GetHTTPOverlay() HTTPContentOverlay

func (p *OverlayStoreProvider) GetStore(name string) Store

func (p *OverlayStoreProvider) StoreNames() []string

func (p *OverlayStoreProvider) Validate() error

type ReadOnlyStoreError ¶

type ReadOnlyStoreError struct {
	Operation string
}

ReadOnlyStoreError indicates an attempt to modify a read-only store.

func (e *ReadOnlyStoreError) Error() string

type RealStoreProvider ¶

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

RealStoreProvider provides access to actual (non-overlaid) stores.

This is the default implementation used during normal reconciliation.

func NewRealStoreProvider(stores map[string]Store) *RealStoreProvider

func (p *RealStoreProvider) GetStore(name string) Store

func (p *RealStoreProvider) StoreNames() []string

type Store ¶

type Store interface {
	// Get retrieves all resources matching the provided index keys.
	Get(keys ...string) ([]any, error)

	// List returns all resources in the store.
	List() ([]any, error)

	// Add inserts a new resource into the store with the provided index keys.
	Add(resource any, keys []string) error

	// Update modifies an existing resource in the store.
	Update(resource any, keys []string) error

	// Delete removes a resource from the store using its index keys.
	Delete(keys ...string) error

	// Clear removes all resources from the store.
	Clear() error
}

Store defines the interface for storing and retrieving indexed resources.

This interface mirrors pkg/k8s/Store but is defined here to maintain package independence. Go's implicit interface satisfaction means any type implementing these methods (like k8s/Store) automatically satisfies this.

type StoreOverlay ¶

type StoreOverlay struct {
	// Additions are new resources to add to the store.
	Additions []runtime.Object

	// Modifications are existing resources with updated content.
	Modifications []runtime.Object

	// Deletions are keys identifying resources to remove.
	// Uses NamespacedName for consistent key format.
	Deletions []ktypes.NamespacedName
	// contains filtered or unexported fields
}

StoreOverlay represents proposed changes to a store.

This enables "what if" scenarios: validate configurations with proposed changes without modifying the actual store state.

Resources are pre-converted to template-friendly format (floats to ints) at construction time to avoid repeated conversion during Get()/List() calls.

func NewStoreOverlay() *StoreOverlay

func NewStoreOverlayForCreate(obj runtime.Object) *StoreOverlay

func NewStoreOverlayForDelete(namespace, name string) *StoreOverlay

func NewStoreOverlayForUpdate(obj runtime.Object) *StoreOverlay

func (o *StoreOverlay) AddAddition(obj runtime.Object)

func (o *StoreOverlay) AddModification(obj runtime.Object)

func (o *StoreOverlay) IsEmpty() bool

type StoreProvider ¶

type StoreProvider interface {
	// GetStore returns the store for the given name.
	// Returns nil if no store exists with that name.
	GetStore(name string) Store

	// StoreNames returns the names of all available stores.
	StoreNames() []string
}

StoreProvider provides access to stores by name.

This abstraction decouples consumers from how stores are obtained, enabling composition and overlaying of proposed changes.

type TypesStoreAdapter ¶

type TypesStoreAdapter struct {
	// Inner is the underlying store to delegate to.
	// It must implement Get, List, Add, Update, Delete, Clear methods
	// with the same signatures as stores.Store.
	Inner interface {
		Get(keys ...string) ([]any, error)
		List() ([]any, error)
		Add(resource any, keys []string) error
		Update(resource any, keys []string) error
		Delete(keys ...string) error
		Clear() error
	}
}

TypesStoreAdapter wraps any type implementing the Store interface methods.

This adapter is needed because k8s/types.Store and stores.Store are identical interfaces defined in different packages. Go's structural typing means concrete types implement both, but interface VALUES cannot be directly assigned across package boundaries.

Example:

typesStore := someManager.GetStore("ingresses") // returns types.Store
storesStore := &TypesStoreAdapter{Inner: typesStore} // now implements stores.Store

func (a *TypesStoreAdapter) Add(resource any, keys []string) error

func (a *TypesStoreAdapter) Clear() error

func (a *TypesStoreAdapter) Delete(keys ...string) error

func (a *TypesStoreAdapter) Get(keys ...string) ([]any, error)

func (a *TypesStoreAdapter) List() ([]any, error)

func (a *TypesStoreAdapter) Update(resource any, keys []string) error

type ValidationContext ¶

type ValidationContext struct {
	// K8sOverlays maps store names to their proposed changes.
	K8sOverlays map[string]*StoreOverlay

	// HTTPOverlay contains pending HTTP content changes.
	// Nil means no HTTP content changes to validate.
	HTTPOverlay HTTPContentOverlay
}

ValidationContext is a unified container for all overlay types.

It holds both K8s store overlays and HTTP content overlays, enabling the render pipeline to apply proposed changes transparently during validation.

Usage:

// For K8s-only validation (webhook admission)
ctx := NewValidationContext(k8sOverlays)

// For HTTP content validation
ctx := NewValidationContext(nil).WithHTTPOverlay(httpOverlay)

// For combined validation
ctx := NewValidationContext(k8sOverlays).WithHTTPOverlay(httpOverlay)

func NewValidationContext(overlays map[string]*StoreOverlay) *ValidationContext

func (c *ValidationContext) IsEmpty() bool

func (c *ValidationContext) WithHTTPOverlay(overlay HTTPContentOverlay) *ValidationContext

ctx := NewValidationContext(overlays).WithHTTPOverlay(httpOverlay)