refactor: abstract versioned cache

I didn't wan't to duplicate the code a fourth time for the extra extensions so here's a little abstraction

Signed-off-by: Orzelius <33936483+Orzelius@users.noreply.github.com>

Author: Orzelius

cmd/image-factory/cmd/service.go

@@ -78,7 +78,9 @@ func RunFactory(ctx context.Context, logger *zap.Logger, opts Options) error {
 
 	defer remotewrap.ShutdownTransport()
 
-	artifactsManager, err := buildArtifactsManager(logger, opts)
+	// artifact fetches intentionally run on their own detached, timeout-bound contexts,
+	// so there's no need to pass context here.
+	artifactsManager, err := buildArtifactsManager(logger, opts) //nolint:contextcheck
 	if err != nil {
 		return err
 	}

internal/artifacts/manager.go

@@ -25,6 +25,7 @@ import (
 	"go.uber.org/zap"
 	"golang.org/x/sync/singleflight"
 
+	"github.com/siderolabs/image-factory/internal/cache"
 	"github.com/siderolabs/image-factory/internal/remotewrap"
 )
 
@@ -39,14 +40,9 @@ type Manager struct { //nolint:govet
 
 	sf singleflight.Group
 
-	officialExtensionsMu sync.Mutex
-	officialExtensions   map[string][]ExtensionRef
-
-	officialOverlaysMu sync.Mutex
-	officialOverlays   map[string][]OverlayRef
-
-	talosctlTuplesMu sync.Mutex
-	talosctlTuples   map[string][]TalosctlTuple
+	officialExtensions *cache.SingleFlightCache[[]ExtensionRef]
+	officialOverlays   *cache.SingleFlightCache[[]OverlayRef]
+	talosctlTuples     *cache.SingleFlightCache[[]TalosctlTuple]
 
 	talosVersionsMu        sync.Mutex
 	talosVersions          []semver.Version
@@ -96,14 +92,28 @@ func NewManager(logger *zap.Logger, options Options) (*Manager, error) {
 		}
 	}
 
-	return &Manager{
+	m := &Manager{
 		options:        options,
 		storagePath:    tmpDir,
 		schematicsPath: schematicsPath,
 		logger:         logger,
 		imageRegistry:  imageRegistry,
 		pullers:        pullers,
-	}, nil
+	}
+
+	m.officialExtensions = cache.NewSingleFlightCache(func(tag string) ([]ExtensionRef, error) {
+		return m.fetchExtensionList(m.options.ExtensionManifestImage, tag)
+	})
+
+	m.officialOverlays = cache.NewSingleFlightCache(func(tag string) ([]OverlayRef, error) {
+		return m.fetchOverlayList(tag)
+	})
+
+	m.talosctlTuples = cache.NewSingleFlightCache(func(tag string) ([]TalosctlTuple, error) {
+		return m.fetchTalosctlTuples(tag)
+	})
+
+	return m, nil
 }
 
 // Close the manager.
@@ -199,77 +209,23 @@ func (m *Manager) GetTalosVersions(ctx context.Context) ([]semver.Version, error
 }
 
 // GetOfficialExtensions returns a list of Talos extensions per Talos version available.
-//
-//nolint:dupl
 func (m *Manager) GetOfficialExtensions(ctx context.Context, versionString string) ([]ExtensionRef, error) {
 	tag, err := m.parseTag(ctx, versionString)
 	if err != nil {
 		return nil, err
 	}
 
-	m.officialExtensionsMu.Lock()
-	extensions, ok := m.officialExtensions[tag]
-	m.officialExtensionsMu.Unlock()
-
-	if ok {
-		return extensions, nil
-	}
-
-	resultCh := m.sf.DoChan("extensions-"+tag, func() (any, error) { //nolint:contextcheck
-		return nil, m.fetchOfficialExtensions(tag)
-	})
-
-	select {
-	case <-ctx.Done():
-		return nil, ctx.Err()
-	case result := <-resultCh:
-		if result.Err != nil {
-			return nil, result.Err
-		}
-	}
-
-	m.officialExtensionsMu.Lock()
-	extensions = m.officialExtensions[tag]
-	m.officialExtensionsMu.Unlock()
-
-	return extensions, nil
+	return m.officialExtensions.Get(ctx, tag)
 }
 
 // GetOfficialOverlays returns a list of overlays per Talos version available.
-//
-//nolint:dupl
 func (m *Manager) GetOfficialOverlays(ctx context.Context, versionString string) ([]OverlayRef, error) {
 	tag, err := m.parseTag(ctx, versionString)
 	if err != nil {
 		return nil, err
 	}
 
-	m.officialOverlaysMu.Lock()
-	overlays, ok := m.officialOverlays[tag]
-	m.officialOverlaysMu.Unlock()
-
-	if ok {
-		return overlays, nil
-	}
-
-	resultCh := m.sf.DoChan("overlays-"+tag, func() (any, error) { //nolint:contextcheck
-		return nil, m.fetchOfficialOverlays(tag)
-	})
-
-	select {
-	case <-ctx.Done():
-		return nil, ctx.Err()
-	case result := <-resultCh:
-		if result.Err != nil {
-			return nil, result.Err
-		}
-	}
-
-	m.officialOverlaysMu.Lock()
-	overlays = m.officialOverlays[tag]
-	m.officialOverlaysMu.Unlock()
-
-	return overlays, nil
+	return m.officialOverlays.Get(ctx, tag)
 }
 
 // GetInstallerImage pulls and stores in OCI layout installer-base image.
@@ -424,44 +380,17 @@ func (m *Manager) GetTalosctlImage(ctx context.Context, versionString string) (s
 }
 
 // GetTalosctlTuples returns a list of Talosctl tuples for the given version.
-//
-//nolint:dupl
 func (m *Manager) GetTalosctlTuples(ctx context.Context, versionString string) ([]TalosctlTuple, error) {
 	tag, err := m.parseTag(ctx, versionString)
 	if err != nil {
 		return nil, err
 	}
 
-	m.talosctlTuplesMu.Lock()
-	tuples, ok := m.talosctlTuples[tag]
-	m.talosctlTuplesMu.Unlock()
-
-	if ok {
-		return tuples, nil
-	}
-
 	if !quirks.New(versionString).SupportsFactoryTalosctlDownload() {
-		return tuples, nil
+		return nil, nil
 	}
 
-	resultCh := m.sf.DoChan("tuples-"+tag, func() (any, error) { //nolint:contextcheck
-		return nil, m.fetchTalosctlTuples(tag)
-	})
-
-	select {
-	case <-ctx.Done():
-		return nil, ctx.Err()
-	case result := <-resultCh:
-		if result.Err != nil {
-			return nil, result.Err
-		}
-	}
-
-	m.talosctlTuplesMu.Lock()
-	tuples = m.talosctlTuples[tag]
-	m.talosctlTuplesMu.Unlock()
-
-	return tuples, nil
+	return m.talosctlTuples.Get(ctx, tag)
 }
 
 func (m *Manager) parseTag(ctx context.Context, versionString string) (string, error) {

internal/artifacts/versions.go

@@ -131,10 +131,10 @@ type overlaysDescription struct {
 	Digest string `yaml:"digest"`
 }
 
-func (m *Manager) fetchOfficialExtensions(tag string) error {
+func (m *Manager) fetchExtensionList(image, tag string) ([]ExtensionRef, error) {
 	var extensions []ExtensionRef
 
-	if err := m.fetchImageByTag(m.options.ExtensionManifestImage, tag, ArchAmd64, imageExportHandler(func(_ *zap.Logger, r io.Reader) error {
+	err := m.fetchImageByTag(image, tag, ArchAmd64, imageExportHandler(func(_ *zap.Logger, r io.Reader) error {
 		var extractErr error
 
 		extensions, extractErr = extractExtensionList(r)
@@ -143,27 +143,15 @@ func (m *Manager) fetchOfficialExtensions(tag string) error {
 		}
 
 		return extractErr
-	})); err != nil {
-		return err
-	}
-
-	m.officialExtensionsMu.Lock()
-
-	if m.officialExtensions == nil {
-		m.officialExtensions = make(map[string][]ExtensionRef)
-	}
-
-	m.officialExtensions[tag] = extensions
+	}))
 
-	m.officialExtensionsMu.Unlock()
-
-	return nil
+	return extensions, err
 }
 
-func (m *Manager) fetchOfficialOverlays(tag string) error {
+func (m *Manager) fetchOverlayList(tag string) ([]OverlayRef, error) {
 	var overlays []OverlayRef
 
-	if err := m.fetchImageByTag(m.options.OverlayManifestImage, tag, ArchAmd64, imageExportHandler(func(_ *zap.Logger, r io.Reader) error {
+	err := m.fetchImageByTag(m.options.OverlayManifestImage, tag, ArchAmd64, imageExportHandler(func(_ *zap.Logger, r io.Reader) error {
 		var extractErr error
 
 		overlays, extractErr = extractOverlayList(r)
@@ -172,27 +160,15 @@ func (m *Manager) fetchOfficialOverlays(tag string) error {
 		}
 
 		return extractErr
-	})); err != nil {
-		return err
-	}
-
-	m.officialOverlaysMu.Lock()
-
-	if m.officialOverlays == nil {
-		m.officialOverlays = make(map[string][]OverlayRef)
-	}
-
-	m.officialOverlays[tag] = overlays
-
-	m.officialOverlaysMu.Unlock()
+	}))
 
-	return nil
+	return overlays, err
 }
 
-func (m *Manager) fetchTalosctlTuples(tag string) error {
+func (m *Manager) fetchTalosctlTuples(tag string) ([]TalosctlTuple, error) {
 	var talosctlTuples []TalosctlTuple
 
-	if err := m.fetchImageByTag(m.options.TalosctlImage, tag, ArchAmd64, imageExportHandler(func(_ *zap.Logger, r io.Reader) error {
+	err := m.fetchImageByTag(m.options.TalosctlImage, tag, ArchAmd64, imageExportHandler(func(_ *zap.Logger, r io.Reader) error {
 		var extractErr error
 
 		talosctlTuples, extractErr = extractTalosctlTuples(r)
@@ -201,21 +177,9 @@ func (m *Manager) fetchTalosctlTuples(tag string) error {
 		}
 
 		return extractErr
-	})); err != nil {
-		return err
-	}
-
-	m.talosctlTuplesMu.Lock()
-
-	if m.talosctlTuples == nil {
-		m.talosctlTuples = make(map[string][]TalosctlTuple)
-	}
-
-	m.talosctlTuples[tag] = talosctlTuples
-
-	m.talosctlTuplesMu.Unlock()
+	}))
 
-	return nil
+	return talosctlTuples, err
 }
 
 //nolint:gocognit

internal/cache/cache.go

@@ -2,9 +2,14 @@
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
-// Package cache provides a capacity-bounded TTL cache with Prometheus metrics
-// and singleflight de-duplication. Consumers compose their own value semantics
-// (negative caching, optional wrapping, etc.) on top of the primitive.
+// Package cache provides reusable in-memory caching primitives.
+//
+// Cache is a capacity-bounded TTL cache with Prometheus metrics and
+// singleflight de-duplication; consumers compose their own value semantics
+// (negative caching, optional wrapping, etc.) on top of it.
+//
+// VersionedCache lazily fetches and caches lists of values keyed by a version
+// tag, de-duplicating concurrent loads and respecting context cancellation.
 package cache
 
 import (

internal/cache/single_flight.go

@@ -0,0 +1,73 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+package cache
+
+import (
+	"context"
+	"sync"
+
+	"golang.org/x/sync/singleflight"
+)
+
+// SingleFlightCache lazily fetches and caches a list of values keyed by a version tag.
+//
+// Fetches are de-duplicated across concurrent callers via an internal
+// singleflight group, and respect the caller's context for cancellation.
+// Failed fetches are not cached.
+type SingleFlightCache[T any] struct {
+	fetch   func(tag string) (T, error)
+	entries map[string]T
+	sf      singleflight.Group
+	mu      sync.Mutex
+}
+
+// NewSingleFlightCache creates a cache that uses fetch to populate missing entries.
+func NewSingleFlightCache[T any](fetch func(tag string) (T, error)) *SingleFlightCache[T] {
+	return &SingleFlightCache[T]{
+		entries: make(map[string]T),
+		fetch:   fetch,
+	}
+}
+
+// Get returns the cached entry for a tag, fetching it if absent.
+func (c *SingleFlightCache[T]) Get(ctx context.Context, tag string) (T, error) {
+	c.mu.Lock()
+	entry, ok := c.entries[tag]
+	c.mu.Unlock()
+
+	if ok {
+		return entry, nil
+	}
+
+	resultCh := c.sf.DoChan(tag, func() (any, error) { //nolint:contextcheck
+		item, err := c.fetch(tag)
+		if err != nil {
+			return nil, err
+		}
+
+		c.mu.Lock()
+		c.entries[tag] = item
+		c.mu.Unlock()
+
+		return item, nil //nolint:nilnil
+	})
+
+	var zero T
+
+	select {
+	case <-ctx.Done():
+		return zero, ctx.Err()
+	case result := <-resultCh:
+		if result.Err != nil {
+			return zero, result.Err
+		}
+	}
+
+	c.mu.Lock()
+	entry = c.entries[tag]
+	c.mu.Unlock()
+
+	return entry, nil
+}