wip 4

Author: dmcilvaney

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

@@ -6,6 +6,7 @@ package component
 import (
 	"fmt"
 	"log/slog"
+	"path/filepath"
 	"sync"
 
 	"github.com/microsoft/azure-linux-dev-tools/internal/app/azldev"
@@ -89,20 +90,14 @@ func ComputeComponentIdentities(
 
 	distroRef := env.Config().Project.DefaultDistro
 
-	// Resolve the distro definition (fills in default version).
-	distroRef, distro, err := resolveDistroForIdentity(env, distroRef)
+	// Resolve the distro definition (fills in default version for the fingerprint).
+	distroRef, _, err = resolveDistroForIdentity(env, distroRef)
 	if err != nil {
 		slog.Debug("Could not resolve distro", "error", err)
 	}
 
-	// Create a source manager — it handles provider construction and dispatch.
-	srcManager, err := sourceproviders.NewSourceManager(env, distro)
-	if err != nil {
-		return nil, fmt.Errorf("creating source manager:\n%w", err)
-	}
-
 	return computeIdentitiesParallel(
-		env, comps.Components(), distroRef, srcManager,
+		env, comps.Components(), distroRef,
 	)
 }
 
@@ -116,7 +111,6 @@ func computeIdentitiesParallel(
 	env *azldev.Env,
 	comps []components.Component,
 	distroRef projectconfig.DistroReference,
-	srcManager sourceproviders.SourceManager,
 ) ([]ComponentIdentityResult, error) {
 	progressEvent := env.StartEvent("Computing component identities",
 		"count", len(comps))
@@ -150,7 +144,7 @@ func computeIdentitiesParallel(
 			}
 
 			result, computeErr := computeSingleIdentity(
-				env, comp, distroRef, srcManager,
+				env, comp, distroRef,
 			)
 
 			resultsChan <- indexedResult{index: compIdx, result: result, err: computeErr}
@@ -189,7 +183,6 @@ func computeSingleIdentity(
 	env *azldev.Env,
 	comp components.Component,
 	distroRef projectconfig.DistroReference,
-	srcManager sourceproviders.SourceManager,
 ) (ComponentIdentityResult, error) {
 	config := comp.GetConfig()
 	componentName := comp.GetName()
@@ -198,12 +191,12 @@ func computeSingleIdentity(
 		AffectsCommitCount: countAffectsCommits(config, componentName),
 	}
 
-	// Resolve source identity via the source manager (handles local/upstream dispatch + retry).
-	sourceIdentity, resolveErr := srcManager.ResolveSourceIdentity(env, comp)
-	if resolveErr != nil {
+	// Resolve source identity, selecting the appropriate method based on source type (local vs. upstream etc.).
+	sourceIdentity, err := resolveSourceIdentityForComponent(env, comp)
+	if err != nil {
 		return ComponentIdentityResult{}, fmt.Errorf(
 			"source identity resolution failed for %#q:\n%w",
-			componentName, resolveErr)
+			componentName, err)
 	}
 
 	identityOpts.SourceIdentity = sourceIdentity
@@ -259,3 +252,52 @@ func countAffectsCommits(
 
 	return commits
 }
+
+// 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.
+func resolveSourceIdentityForComponent(
+	env *azldev.Env, comp components.Component,
+) (string, error) {
+	sourceType := comp.GetConfig().Spec.SourceType
+
+	// Local components: hash the spec directory directly without a source manager.
+	if sourceType == projectconfig.SpecSourceTypeLocal ||
+		sourceType == projectconfig.SpecSourceTypeUnspecified {
+		specDir := ""
+		if comp.GetConfig().Spec.Path != "" {
+			specDir = filepath.Dir(comp.GetConfig().Spec.Path)
+		}
+
+		identity, localErr := sourceproviders.NewLocalIdentityProvider(env.FS(), specDir).
+			ResolveSourceIdentity(env, comp)
+		if localErr != nil {
+			return "", fmt.Errorf("resolving local source identity for %#q:\n%w",
+				comp.GetName(), localErr)
+		}
+
+		return identity, nil
+	}
+
+	// Upstream components: need a source manager with the component's resolved distro.
+	distro, err := sourceproviders.ResolveDistro(env, comp)
+	if err != nil {
+		return "", fmt.Errorf("resolving distro for component %#q:\n%w",
+			comp.GetName(), err)
+	}
+
+	srcManager, err := sourceproviders.NewSourceManager(env, distro)
+	if err != nil {
+		return "", fmt.Errorf("creating source manager for component %#q:\n%w",
+			comp.GetName(), err)
+	}
+
+	identity, err := srcManager.ResolveSourceIdentity(env, comp)
+	if err != nil {
+		return "", fmt.Errorf("resolving upstream source identity for %#q:\n%w",
+			comp.GetName(), err)
+	}
+
+	return identity, nil
+}

internal/fingerprint/fingerprint.go

@@ -91,7 +91,7 @@ func ComputeIdentity(
 
 	inputs.OverlayFileHashes = overlayHashes
 
-	// 4. Combine all inputs into the overall fingerprint.
+	// 3. Combine all inputs into the overall fingerprint.
 	return &ComponentIdentity{
 		Fingerprint: combineInputs(inputs),
 		Inputs:      inputs,

internal/fingerprint/fingerprint_test.go

@@ -535,3 +535,31 @@ func TestComputeIdentity_MergeUpdatesFromPropagation(t *testing.T) {
 	assert.NotEqual(t, fpBefore, fpAfter,
 		"merged distro default must change the fingerprint")
 }
+
+func TestComputeIdentity_SnapshotChangeDoesNotAffectFingerprint(t *testing.T) {
+	ctx := newTestFS(t, nil)
+
+	comp := projectconfig.ComponentConfig{
+		Spec: projectconfig.SpecSource{
+			SourceType:     projectconfig.SpecSourceTypeUpstream,
+			UpstreamName:   "curl",
+			UpstreamCommit: "abc1234",
+			UpstreamDistro: projectconfig.DistroReference{
+				Name:     "fedora",
+				Version:  "41",
+				Snapshot: "2025-01-01T00:00:00Z",
+			},
+		},
+	}
+	distro := baseDistroRef()
+
+	fp1 := computeFingerprint(t, ctx, comp, distro, 0)
+
+	// Change only the snapshot timestamp.
+	comp.Spec.UpstreamDistro.Snapshot = "2026-06-15T00:00:00Z"
+	fp2 := computeFingerprint(t, ctx, comp, distro, 0)
+
+	assert.Equal(t, fp1, fp2,
+		"changing upstream distro snapshot must NOT change fingerprint "+
+			"(snapshot is excluded; resolved commit hash is what matters)")
+}

internal/projectconfig/distro.go

@@ -18,7 +18,7 @@ type DistroReference struct {
 	// Version of the referenced distro.
 	Version string `toml:"version,omitempty" json:"version,omitempty" jsonschema:"title=Version,description=Version of the referenced distro"`
 	// Snapshot date/time for source code if specified components will use source as it existed at this time.
-	Snapshot string `toml:"snapshot,omitempty" json:"snapshot,omitempty" jsonschema:"format=date-time,title=Snapshot,description=If specified use source code as it existed at this date/time"`
+	Snapshot string `toml:"snapshot,omitempty" json:"snapshot,omitempty" jsonschema:"format=date-time,title=Snapshot,description=If specified use source code as it existed at this date/time" fingerprint:"-"`
 }
 
 // Implements the [Stringer] interface for [DistroReference].

internal/projectconfig/fingerprint_test.go

@@ -38,31 +38,43 @@ func TestAllFingerprintedFieldsHaveDecision(t *testing.T) {
 
 	// Maps "StructName.FieldName" for every field that should carry a
 	// `fingerprint:"-"` tag. Catches accidental tag removal.
+	//
+	// Each entry documents WHY the field is excluded from the fingerprint:
 	expectedExclusions := map[string]bool{
-		// ComponentConfig
-		"ComponentConfig.Name":             true,
+		// ComponentConfig.Name — metadata, already the map key in project config.
+		"ComponentConfig.Name": true,
+		// ComponentConfig.SourceConfigFile — internal bookkeeping reference, not a build input.
 		"ComponentConfig.SourceConfigFile": true,
 
-		// ComponentBuildConfig
+		// ComponentBuildConfig.Failure — CI policy (expected failure tracking), not a build input.
 		"ComponentBuildConfig.Failure": true,
-		"ComponentBuildConfig.Hints":   true,
+		// ComponentBuildConfig.Hints — scheduling hints (e.g. expensive), not a build input.
+		"ComponentBuildConfig.Hints": true,
 
-		// CheckConfig
+		// CheckConfig.SkipReason — human documentation for why check is skipped, not a build input.
 		"CheckConfig.SkipReason": true,
 
 		// ComponentBuildFailureConfig — entire struct excluded via parent, but individual
 		// fields are also tagged so reflection on the struct alone is consistent.
-		"ComponentBuildFailureConfig.Expected":       true,
+		// ComponentBuildFailureConfig.Expected — CI decision about expected failures.
+		"ComponentBuildFailureConfig.Expected": true,
+		// ComponentBuildFailureConfig.ExpectedReason — documentation for expected failure.
 		"ComponentBuildFailureConfig.ExpectedReason": true,
 
 		// ComponentBuildHints — entire struct excluded via parent, fields also tagged.
+		// ComponentBuildHints.Expensive — scheduling hint, does not affect build output.
 		"ComponentBuildHints.Expensive": true,
 
-		// ComponentOverlay
+		// ComponentOverlay.Description — human-readable documentation for the overlay.
 		"ComponentOverlay.Description": true,
 
-		// SourceFileReference
+		// SourceFileReference.Component — back-reference to parent, not a build input.
 		"SourceFileReference.Component": true,
+
+		// DistroReference.Snapshot — snapshot timestamp is not a build input; the resolved
+		// upstream commit hash (captured separately via SourceIdentity) is what matters.
+		// Excluding this prevents a snapshot bump from marking all upstream components as changed.
+		"DistroReference.Snapshot": true,
 	}
 
 	// Collect all actual exclusions found via reflection.

internal/providers/sourceproviders/fedorasourceprovider.go

@@ -274,19 +274,33 @@ func (g *FedoraSourcesProviderImpl) checkoutTargetCommit(
 }
 
 // ResolveSourceIdentity implements [SourceIdentityProvider] by resolving the upstream
-// commit hash for the component. Uses the same resolution priority as [checkoutTargetCommit].
+// 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.
 func (g *FedoraSourcesProviderImpl) ResolveSourceIdentity(
 	ctx context.Context,
 	component components.Component,
 ) (string, error) {
+	// Case 1: Explicit upstream commit hash — no network call needed.
+	if pinnedCommit := component.GetConfig().Spec.UpstreamCommit; pinnedCommit != "" {
+		slog.Debug("Using pinned upstream commit for identity",
+			"component", component.GetName(),
+			"commit", pinnedCommit)
+
+		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)
 
-	// Query HEAD of the dist-git branch with retry for transient failures.
 	var commitHash string
 
 	retryErr := retry.Do(ctx, g.retryConfig, func() error {

internal/providers/sourceproviders/identityprovider_test.go

@@ -139,6 +139,22 @@ func TestFedoraProvider_ResolveSourceIdentity(t *testing.T) {
 		require.Error(t, resolveErr)
 		assert.Contains(t, resolveErr.Error(), testPackageName)
 	})
+
+	t.Run("returns pinned commit without network call", func(t *testing.T) {
+		pinnedCommit := "deadbeef12345678"
+		comp := newMockCompWithConfig(ctrl, testPackageName, &projectconfig.ComponentConfig{
+			Name: testPackageName,
+			Spec: projectconfig.SpecSource{
+				SourceType:     projectconfig.SpecSourceTypeUpstream,
+				UpstreamCommit: pinnedCommit,
+			},
+		})
+
+		// No LsRemoteHead expectation — the pinned commit should be returned directly.
+		identity, resolveErr := provider.ResolveSourceIdentity(t.Context(), comp)
+		require.NoError(t, resolveErr)
+		assert.Equal(t, pinnedCommit, identity)
+	})
 }
 
 // --- RPMContentsProviderImpl.ResolveSourceIdentity tests ---
@@ -184,12 +200,19 @@ func TestRPMProvider_ResolveSourceIdentity(t *testing.T) {
 
 // newMockComp creates a mock component with the given name and an empty upstream config.
 func newMockComp(ctrl *gomock.Controller, name string) *components_testutils.MockComponent {
-	comp := components_testutils.NewMockComponent(ctrl)
-	comp.EXPECT().GetName().AnyTimes().Return(name)
-	comp.EXPECT().GetConfig().AnyTimes().Return(&projectconfig.ComponentConfig{
+	return newMockCompWithConfig(ctrl, name, &projectconfig.ComponentConfig{
 		Name: name,
 		Spec: projectconfig.SpecSource{},
 	})
+}
+
+// newMockCompWithConfig creates a mock component with the given name and a custom config.
+func newMockCompWithConfig(
+	ctrl *gomock.Controller, name string, config *projectconfig.ComponentConfig,
+) *components_testutils.MockComponent {
+	comp := components_testutils.NewMockComponent(ctrl)
+	comp.EXPECT().GetName().AnyTimes().Return(name)
+	comp.EXPECT().GetConfig().AnyTimes().Return(config)
 
 	return comp
 }