rework git

Author: dmcilvaney

internal/app/azldev/cmds/component/identity.go

@@ -28,7 +28,7 @@ func identityOnAppInit(_ *azldev.App, parentCmd *cobra.Command) {
 	parentCmd.AddCommand(NewComponentIdentityCommand())
 }
 
-// Constructs a [cobra.Command] for "component identity" CLI subcommand.
+// NewComponentIdentityCommand constructs a [cobra.Command] for "component identity" CLI subcommand.
 func NewComponentIdentityCommand() *cobra.Command {
 	options := &IdentityComponentOptions{}
 
@@ -116,6 +116,10 @@ func computeIdentitiesParallel(
 		"count", len(comps))
 	defer progressEvent.End()
 
+	// Create a cancellable child env so we can stop remaining goroutines on first error.
+	workerEnv, cancel := env.WithCancel()
+	defer cancel()
+
 	type indexedResult struct {
 		index  int
 		result ComponentIdentityResult
@@ -137,14 +141,14 @@ func computeIdentitiesParallel(
 			select {
 			case semaphore <- struct{}{}:
 				defer func() { <-semaphore }()
-			case <-env.Done():
-				resultsChan <- indexedResult{index: compIdx, err: env.Err()}
+			case <-workerEnv.Done():
+				resultsChan <- indexedResult{index: compIdx, err: workerEnv.Err()}
 
 				return
 			}
 
 			result, computeErr := computeSingleIdentity(
-				env, comp, distroRef,
+				workerEnv, comp, distroRef,
 			)
 
 			resultsChan <- indexedResult{index: compIdx, result: result, err: computeErr}
@@ -163,15 +167,28 @@ func computeIdentitiesParallel(
 	var completed int64
 
 	total := int64(len(comps))
+	var firstErr error
 
 	for indexed := range resultsChan {
 		if indexed.err != nil {
-			return nil, indexed.err
+			if firstErr == nil {
+				firstErr = indexed.err
+				cancel()
+			}
+
+			// Drain remaining results so the closer goroutine can finish.
+			continue
 		}
 
-		results[indexed.index] = indexed.result
-		completed++
-		progressEvent.SetProgress(completed, total)
+		if firstErr == nil {
+			results[indexed.index] = indexed.result
+			completed++
+			progressEvent.SetProgress(completed, total)
+		}
+	}
+
+	if firstErr != nil {
+		return nil, firstErr
 	}
 
 	return results, nil
@@ -188,7 +205,7 @@ func computeSingleIdentity(
 	componentName := comp.GetName()
 
 	identityOpts := fingerprint.IdentityOptions{
-		AffectsCommitCount: countAffectsCommits(config, componentName),
+		AffectsCommitCount: countAffectsCommits(env, config, componentName),
 	}
 
 	// Resolve source identity, selecting the appropriate method based on source type (local vs. upstream etc.).
@@ -236,9 +253,9 @@ func resolveDistroForIdentity(
 // countAffectsCommits counts the number of "Affects: <componentName>" commits in the
 // project repo. Returns 0 if the count cannot be determined (e.g., no git repo).
 func countAffectsCommits(
-	config *projectconfig.ComponentConfig, componentName string,
+	env *azldev.Env, config *projectconfig.ComponentConfig, componentName string,
 ) int {
-	commits, err := sources.CountAffectsCommits(config, componentName)
+	commits, err := sources.CountAffectsCommits(env.Context(), config, componentName)
 	if err != nil {
 		slog.Debug("Could not count Affects commits; defaulting to 0",
 			"component", componentName, "error", err)
@@ -251,8 +268,14 @@ func countAffectsCommits(
 
 // resolveSourceIdentityForComponent returns a deterministic identity string for the
 // component's source. Local components are handled directly (spec directory hash) to
-// avoid constructing a full source manager. Upstream components go through the source
-// manager which handles provider dispatch and retry.
+// avoid constructing a full [sourceproviders.SourceManager]. This avoids the overhead of
+// resolving a distro and creating upstream providers that won't be used, and ensures
+// local-only projects (with no distro configured) work without error.
+// Upstream components go through the source manager which handles provider dispatch
+// and retry.
+//
+// NOTE: This logic mirrors [sourceproviders.sourceManager.ResolveSourceIdentity] for the
+// local path. Changes to source type dispatch must be kept in sync.
 func resolveSourceIdentityForComponent(
 	env *azldev.Env, comp components.Component,
 ) (string, error) {

internal/app/azldev/core/sources/sourceprep.go

@@ -157,7 +157,7 @@ func (p *sourcePreparerImpl) PrepareSources(
 
 	// Record the changes as synthetic git history when dist-git creation is enabled.
 	if p.withGitRepo {
-		if err := p.trySyntheticHistory(component, outputDir); err != nil {
+		if err := p.trySyntheticHistory(ctx, component, outputDir); err != nil {
 			return fmt.Errorf("failed to generate synthetic history for component %#q:\n%w",
 				component.GetName(), err)
 		}
@@ -296,13 +296,14 @@ func initSourcesRepo(sourcesDirPath string) (*gogit.Repository, error) {
 // Returns nil when there are no Affects commits to apply.
 // Returns a non-nil error if history generation fails.
 func (p *sourcePreparerImpl) trySyntheticHistory(
+	ctx context.Context,
 	component components.Component,
 	sourcesDirPath string,
 ) error {
 	config := component.GetConfig()
 
 	// Build commit metadata from Affects commits.
-	commits, err := buildSyntheticCommits(config, component.GetName())
+	commits, err := buildSyntheticCommits(ctx, config, component.GetName())
 	if err != nil {
 		return fmt.Errorf("failed to build synthetic commits:\n%w", err)
 	}

internal/app/azldev/core/sources/synthistory.go

@@ -4,6 +4,7 @@
 package sources
 
 import (
+	"context"
 	"errors"
 	"fmt"
 	"log/slog"
@@ -43,8 +44,8 @@ type CommitMetadata struct {
 
 // FindAffectsCommits walks the git log from HEAD and returns metadata for all commits
 // whose message contains "Affects: <componentName>". Results are sorted chronologically
-// (oldest first).
-func FindAffectsCommits(repo *gogit.Repository, componentName string) ([]CommitMetadata, error) {
+// (oldest first). The ctx parameter is checked between commits for early cancellation.
+func FindAffectsCommits(ctx context.Context, repo *gogit.Repository, componentName string) ([]CommitMetadata, error) {
 	head, err := repo.Head()
 	if err != nil {
 		return nil, fmt.Errorf("failed to get HEAD reference:\n%w", err)
@@ -60,6 +61,10 @@ func FindAffectsCommits(repo *gogit.Repository, componentName string) ([]CommitM
 	re := regexp.MustCompile(affectsRegexPattern + regexp.QuoteMeta(componentName) + `(?:$|\s|[,;])`)
 
 	err = commitIter.ForEach(func(commit *object.Commit) error {
+		if ctx.Err() != nil {
+			return ctx.Err()
+		}
+
 		if re.MatchString(commit.Message) {
 			matches = append(matches, CommitMetadata{
 				Hash:        commit.Hash.String(),
@@ -86,7 +91,7 @@ func FindAffectsCommits(repo *gogit.Repository, componentName string) ([]CommitM
 // project repository that contains the component's config file. Returns 0 and an error
 // if the repository cannot be opened or the config file path is unavailable.
 func CountAffectsCommits(
-	config *projectconfig.ComponentConfig, componentName string,
+	ctx context.Context, config *projectconfig.ComponentConfig, componentName string,
 ) (int, error) {
 	configFilePath, err := resolveConfigFilePath(config, componentName)
 	if err != nil {
@@ -98,7 +103,7 @@ func CountAffectsCommits(
 		return 0, fmt.Errorf("opening project repo:\n%w", err)
 	}
 
-	commits, err := FindAffectsCommits(projectRepo, componentName)
+	commits, err := FindAffectsCommits(ctx, projectRepo, componentName)
 	if err != nil {
 		return 0, fmt.Errorf("finding Affects commits:\n%w", err)
 	}
@@ -164,7 +169,7 @@ func CommitSyntheticHistory(
 //
 // Returns nil when no matching commits are found.
 func buildSyntheticCommits(
-	config *projectconfig.ComponentConfig, componentName string,
+	ctx context.Context, config *projectconfig.ComponentConfig, componentName string,
 ) ([]CommitMetadata, error) {
 	configFilePath, err := resolveConfigFilePath(config, componentName)
 	if err != nil {
@@ -180,7 +185,7 @@ func buildSyntheticCommits(
 		return nil, err
 	}
 
-	affectsCommits, err := FindAffectsCommits(projectRepo, componentName)
+	affectsCommits, err := FindAffectsCommits(ctx, projectRepo, componentName)
 	if err != nil {
 		return nil, fmt.Errorf("failed to find Affects commits for component %#q:\n%w", componentName, err)
 	}

internal/app/azldev/core/sources/synthistory_test.go

@@ -81,7 +81,7 @@ func TestFindAffectsCommits(t *testing.T) {
 		"Charlie", "charlie@example.com",
 		time.Date(2025, 3, 1, 10, 0, 0, 0, time.UTC))
 
-	results, err := sources.FindAffectsCommits(repo, "curl")
+	results, err := sources.FindAffectsCommits(t.Context(), repo, "curl")
 	require.NoError(t, err)
 
 	// Expect 2 matching commits, oldest first.
@@ -107,7 +107,7 @@ func TestFindAffectsCommits_NoMatches(t *testing.T) {
 		"Alice", "alice@example.com",
 		time.Date(2025, 1, 1, 10, 0, 0, 0, time.UTC))
 
-	results, err := sources.FindAffectsCommits(repo, "curl")
+	results, err := sources.FindAffectsCommits(t.Context(), repo, "curl")
 	require.NoError(t, err)
 	assert.Empty(t, results)
 }
@@ -130,13 +130,13 @@ func TestFindAffectsCommits_MultipleComponents(t *testing.T) {
 		"Charlie", "charlie@example.com",
 		time.Date(2025, 3, 1, 10, 0, 0, 0, time.UTC))
 
-	curlResults, err := sources.FindAffectsCommits(repo, "curl")
+	curlResults, err := sources.FindAffectsCommits(t.Context(), repo, "curl")
 	require.NoError(t, err)
 	require.Len(t, curlResults, 2, "curl should match 2 commits")
 	assert.Equal(t, "Alice", curlResults[0].Author)
 	assert.Equal(t, "Charlie", curlResults[1].Author)
 
-	wgetResults, err := sources.FindAffectsCommits(repo, "wget")
+	wgetResults, err := sources.FindAffectsCommits(t.Context(), repo, "wget")
 	require.NoError(t, err)
 	require.Len(t, wgetResults, 2, "wget should match 2 commits")
 	assert.Equal(t, "Bob", wgetResults[0].Author)
@@ -158,13 +158,13 @@ func TestFindAffectsCommits_NoSubstringMatch(t *testing.T) {
 		time.Date(2025, 2, 1, 10, 0, 0, 0, time.UTC))
 
 	// Searching for "curl" matches only Bob's commit (exact component name).
-	curlResults, err := sources.FindAffectsCommits(repo, "curl")
+	curlResults, err := sources.FindAffectsCommits(t.Context(), repo, "curl")
 	require.NoError(t, err)
 	require.Len(t, curlResults, 1, "exact match should not include curl-minimal commit")
 	assert.Equal(t, "Bob", curlResults[0].Author)
 
 	// Searching for "curl-minimal" matches only Alice's commit.
-	minimalResults, err := sources.FindAffectsCommits(repo, "curl-minimal")
+	minimalResults, err := sources.FindAffectsCommits(t.Context(), repo, "curl-minimal")
 	require.NoError(t, err)
 	require.Len(t, minimalResults, 1)
 	assert.Equal(t, "Alice", minimalResults[0].Author)
@@ -179,7 +179,7 @@ func TestFindAffectsCommits_AffectsInSubject(t *testing.T) {
 		"Alice", "alice@example.com",
 		time.Date(2025, 1, 1, 10, 0, 0, 0, time.UTC))
 
-	results, err := sources.FindAffectsCommits(repo, "curl")
+	results, err := sources.FindAffectsCommits(t.Context(), repo, "curl")
 	require.NoError(t, err)
 	require.Len(t, results, 1)
 	assert.Equal(t, "Alice", results[0].Author)
@@ -204,13 +204,13 @@ func TestFindAffectsCommits_CaseSensitive(t *testing.T) {
 		time.Date(2025, 3, 1, 10, 0, 0, 0, time.UTC))
 
 	// Matching is case-sensitive: searching for "kernel" only matches the exact-case commit.
-	results, err := sources.FindAffectsCommits(repo, "kernel")
+	results, err := sources.FindAffectsCommits(t.Context(), repo, "kernel")
 	require.NoError(t, err)
 	require.Len(t, results, 1)
 	assert.Equal(t, "Charlie", results[0].Author)
 
 	// Searching for "Kernel" matches only Alice's commit (exact case on component name).
-	results, err = sources.FindAffectsCommits(repo, "Kernel")
+	results, err = sources.FindAffectsCommits(t.Context(), repo, "Kernel")
 	require.NoError(t, err)
 	require.Len(t, results, 1)
 	assert.Equal(t, "Alice", results[0].Author)

internal/app/azldev/env.go

@@ -211,6 +211,19 @@ func (env *Env) Context() context.Context {
 	return env.ctx
 }
 
+// WithCancel returns a shallow copy of the [Env] with a child [context.Context]
+// derived from [context.WithCancel]. The returned [Env] shares all features
+// (FS, config, event listener, cmd factory, etc.) with the original but has an
+// independently cancellable context. The caller must call the returned
+// [context.CancelFunc] when done.
+func (env *Env) WithCancel() (*Env, context.CancelFunc) {
+	childCtx, cancel := context.WithCancel(env.ctx)
+	childEnv := *env
+	childEnv.ctx = childCtx
+
+	return &childEnv, cancel
+}
+
 // ConfirmAutoResolution prompts the user to confirm auto-resolution of a problem. The provided
 // text is displayed to the user as explanation.
 func (env *Env) ConfirmAutoResolution(text string) bool {

internal/providers/sourceproviders/fedorasourceprovider.go

@@ -124,6 +124,9 @@ func (g *FedoraSourcesProviderImpl) GetComponent(
 	defer fileutils.RemoveAllAndUpdateErrorIfNil(g.fs, tempDir, &err)
 
 	// Clone the repository to temp directory with retry for transient network failures.
+	// NOTE: We intentionally do a full clone here (no --shallow-since) because downstream
+	// consumers need complete history — rpmautospec's %autorelease counts commits to compute
+	// the release number etc.
 	err = retry.Do(ctx, g.retryConfig, func() error {
 		// Clean up temp directory contents from any prior failed clone attempt.
 		_ = g.fs.RemoveAll(tempDir)
@@ -276,10 +279,8 @@ func (g *FedoraSourcesProviderImpl) checkoutTargetCommit(
 // ResolveSourceIdentity implements [SourceIdentityProvider] by resolving the upstream
 // commit hash for the component. Resolution priority matches [checkoutTargetCommit]:
 //  1. Explicit upstream commit hash (pinned per-component) — returned directly.
-//  2. Otherwise — query HEAD of the dist-git branch via ls-remote.
-//
-// Snapshot-time resolution is not supported here because it requires a full clone
-// to walk git history. Snapshot changes are tracked separately via the config hash.
+//  2. Snapshot time — shallow clone + rev-list to find the commit at the snapshot date.
+//  3. Default — query HEAD of the dist-git branch via ls-remote.
 func (g *FedoraSourcesProviderImpl) ResolveSourceIdentity(
 	ctx context.Context,
 	component components.Component,
@@ -293,14 +294,78 @@ func (g *FedoraSourcesProviderImpl) ResolveSourceIdentity(
 		return pinnedCommit, nil
 	}
 
-	// Case 2: Query HEAD of the dist-git branch.
 	upstreamName := component.GetConfig().Spec.UpstreamName
 	if upstreamName == "" {
 		upstreamName = component.GetName()
 	}
 
 	gitRepoURL := strings.ReplaceAll(g.distroGitBaseURI, "$pkg", upstreamName)
 
+	// Case 2: Snapshot time — need a shallow clone to resolve the commit at that date.
+	if g.snapshotTime != "" {
+		return g.resolveSnapshotCommit(ctx, gitRepoURL, upstreamName)
+	}
+
+	// Case 3: No snapshot — query HEAD of the dist-git branch via ls-remote.
+	return g.resolveBranchHead(ctx, gitRepoURL, upstreamName)
+}
+
+// resolveSnapshotCommit clones the branch with --shallow-since and resolves the
+// commit at (or before) the configured snapshot time.
+func (g *FedoraSourcesProviderImpl) resolveSnapshotCommit(
+	ctx context.Context, gitRepoURL string, upstreamName string,
+) (string, error) {
+	snapshotDateTime, err := time.Parse(time.RFC3339, g.snapshotTime)
+	if err != nil {
+		return "", fmt.Errorf("invalid snapshot time %#q:\n%w", g.snapshotTime, err)
+	}
+
+	tempDir, err := fileutils.MkdirTempInTempDir(g.fs, "azldev-identity-snapshot-")
+	if err != nil {
+		return "", fmt.Errorf("creating temp directory for snapshot clone:\n%w", err)
+	}
+
+	defer func() {
+		if removeErr := g.fs.RemoveAll(tempDir); removeErr != nil {
+			slog.Debug("Failed to clean up snapshot clone temp directory",
+				"path", tempDir, "error", removeErr)
+		}
+	}()
+
+	// Clone a single branch to resolve the snapshot commit. We use a full
+	// (non-shallow) clone because not all git servers support --shallow-since
+	// (e.g., Pagure returns "the remote end hung up unexpectedly").
+	err = retry.Do(ctx, g.retryConfig, func() error {
+		_ = g.fs.RemoveAll(tempDir)
+		_ = fileutils.MkdirAll(g.fs, tempDir)
+
+		return g.gitProvider.Clone(ctx, gitRepoURL, tempDir,
+			git.WithGitBranch(g.distroGitBranch),
+			git.WithQuiet(),
+		)
+	})
+	if err != nil {
+		return "", fmt.Errorf("shallow clone for snapshot identity of %#q:\n%w", upstreamName, err)
+	}
+
+	commitHash, err := g.gitProvider.GetCommitHashBeforeDate(ctx, tempDir, snapshotDateTime)
+	if err != nil {
+		return "", fmt.Errorf("resolving snapshot commit for %#q at %s:\n%w",
+			upstreamName, snapshotDateTime.Format(time.RFC3339), err)
+	}
+
+	slog.Debug("Resolved snapshot commit for identity",
+		"component", upstreamName,
+		"snapshot", g.snapshotTime,
+		"commit", commitHash)
+
+	return commitHash, nil
+}
+
+// resolveBranchHead queries the HEAD commit of the dist-git branch via ls-remote.
+func (g *FedoraSourcesProviderImpl) resolveBranchHead(
+	ctx context.Context, gitRepoURL string, upstreamName string,
+) (string, error) {
 	var commitHash string
 
 	retryErr := retry.Do(ctx, g.retryConfig, func() error {