wip 3

Author: dmcilvaney

docs/user/reference/cli/azldev_component_identity.md

@@ -13,17 +13,14 @@ import (
 	"github.com/microsoft/azure-linux-dev-tools/internal/app/azldev/core/sources"
 	"github.com/microsoft/azure-linux-dev-tools/internal/fingerprint"
 	"github.com/microsoft/azure-linux-dev-tools/internal/projectconfig"
-	"github.com/microsoft/azure-linux-dev-tools/internal/utils/git"
-	"github.com/microsoft/azure-linux-dev-tools/internal/utils/retry"
+	"github.com/microsoft/azure-linux-dev-tools/internal/providers/sourceproviders"
 	"github.com/spf13/cobra"
 )
 
 // Options for computing component identity fingerprints.
 type IdentityComponentOptions struct {
 	// Standard filter for selecting components.
 	ComponentFilter components.ComponentFilter
-	// Strict causes the command to fail if any upstream commit cannot be resolved.
-	Strict bool
 }
 
 func identityOnAppInit(_ *azldev.App, parentCmd *cobra.Command) {
@@ -66,9 +63,6 @@ rebuilding between two commits.`,
 	azldev.ExportAsMCPTool(cmd)
 	components.AddComponentFilterOptionsToCommand(cmd, &options.ComponentFilter)
 
-	cmd.Flags().BoolVar(&options.Strict, "strict", false,
-		"fail if any upstream commit cannot be resolved (recommended for CI)")
-
 	return cmd
 }
 
@@ -95,23 +89,20 @@ func ComputeComponentIdentities(
 
 	distroRef := env.Config().Project.DefaultDistro
 
-	// Set up upstream resolver for floating upstream specs.
-	gitProvider, err := git.NewGitProviderImpl(env, env)
+	// Resolve the distro definition (fills in default version).
+	distroRef, distro, err := resolveDistroForIdentity(env, distroRef)
 	if err != nil {
-		return nil, fmt.Errorf("creating git provider:\n%w", err)
+		slog.Debug("Could not resolve distro", "error", err)
 	}
 
-	upstreamResolver := fingerprint.NewUpstreamResolver(gitProvider)
-
-	// Resolve the upstream distro definition for upstream commit resolution.
-	distroRef, distroDef, distroVersionDef, err := resolveDistroForIdentity(env, distroRef)
+	// Create a source manager — it handles provider construction and dispatch.
+	srcManager, err := sourceproviders.NewSourceManager(env, distro)
 	if err != nil {
-		slog.Debug("Could not resolve distro for upstream commit resolution",
-			"error", err)
+		return nil, fmt.Errorf("creating source manager:\n%w", err)
 	}
 
 	return computeIdentitiesParallel(
-		env, comps.Components(), distroRef, distroDef, distroVersionDef, upstreamResolver, options.Strict,
+		env, comps.Components(), distroRef, srcManager,
 	)
 }
 
@@ -120,15 +111,12 @@ func ComputeComponentIdentities(
 const maxConcurrentIdentity = 32
 
 // computeIdentitiesParallel computes fingerprints for all components concurrently,
-// including upstream commit resolution, affects count, and file hashing.
+// including source identity resolution, affects count, and overlay file hashing.
 func computeIdentitiesParallel(
 	env *azldev.Env,
 	comps []components.Component,
 	distroRef projectconfig.DistroReference,
-	distroDef projectconfig.DistroDefinition,
-	distroVersionDef projectconfig.DistroVersionDefinition,
-	upstreamResolver *fingerprint.UpstreamResolver,
-	strict bool,
+	srcManager sourceproviders.SourceManager,
 ) ([]ComponentIdentityResult, error) {
 	progressEvent := env.StartEvent("Computing component identities",
 		"count", len(comps))
@@ -142,7 +130,6 @@ func computeIdentitiesParallel(
 
 	resultsChan := make(chan indexedResult, len(comps))
 	semaphore := make(chan struct{}, maxConcurrentIdentity)
-	retryCfg := retry.DefaultConfig()
 
 	var waitGroup sync.WaitGroup
 
@@ -163,7 +150,7 @@ func computeIdentitiesParallel(
 			}
 
 			result, computeErr := computeSingleIdentity(
-				env, comp, distroRef, distroDef, distroVersionDef, upstreamResolver, retryCfg, strict,
+				env, comp, distroRef, srcManager,
 			)
 
 			resultsChan <- indexedResult{index: compIdx, result: result, err: computeErr}
@@ -197,16 +184,12 @@ func computeIdentitiesParallel(
 }
 
 // computeSingleIdentity computes the identity for a single component, including
-// upstream commit resolution (with retry) and affects commit counting.
+// source identity resolution, affects commit counting, and overlay file hashing.
 func computeSingleIdentity(
 	env *azldev.Env,
 	comp components.Component,
 	distroRef projectconfig.DistroReference,
-	distroDef projectconfig.DistroDefinition,
-	distroVersionDef projectconfig.DistroVersionDefinition,
-	upstreamResolver *fingerprint.UpstreamResolver,
-	retryCfg retry.Config,
-	strict bool,
+	srcManager sourceproviders.SourceManager,
 ) (ComponentIdentityResult, error) {
 	config := comp.GetConfig()
 	componentName := comp.GetName()
@@ -215,20 +198,16 @@ func computeSingleIdentity(
 		AffectsCommitCount: countAffectsCommits(config, componentName),
 	}
 
-	// Resolve upstream commit for upstream specs (with retry for transient failures).
-	if config.Spec.SourceType == projectconfig.SpecSourceTypeUpstream {
-		resolvedCommit, resolveErr := resolveUpstreamWithRetry(
-			env, upstreamResolver, componentName, config, distroDef, distroVersionDef, retryCfg,
-		)
-		if resolveErr != nil && strict {
-			return ComponentIdentityResult{}, fmt.Errorf(
-				"upstream commit resolution failed for %#q (--strict mode):\n%w",
-				componentName, resolveErr)
-		}
-
-		identityOpts.ResolvedUpstreamCommit = resolvedCommit
+	// Resolve source identity via the source manager (handles local/upstream dispatch + retry).
+	sourceIdentity, resolveErr := srcManager.ResolveSourceIdentity(env, comp)
+	if resolveErr != nil {
+		return ComponentIdentityResult{}, fmt.Errorf(
+			"source identity resolution failed for %#q:\n%w",
+			componentName, resolveErr)
 	}
 
+	identityOpts.SourceIdentity = sourceIdentity
+
 	identity, err := fingerprint.ComputeIdentity(env.FS(), *config, distroRef, identityOpts)
 	if err != nil {
 		return ComponentIdentityResult{}, fmt.Errorf("computing identity for component %#q:\n%w",
@@ -242,53 +221,14 @@ func computeSingleIdentity(
 	}, nil
 }
 
-// resolveUpstreamWithRetry resolves an upstream commit with retry logic, returning
-// the resolved commit or empty string and an error on failure.
-func resolveUpstreamWithRetry(
-	env *azldev.Env,
-	resolver *fingerprint.UpstreamResolver,
-	componentName string,
-	config *projectconfig.ComponentConfig,
-	distroDef projectconfig.DistroDefinition,
-	distroVersionDef projectconfig.DistroVersionDefinition,
-	retryCfg retry.Config,
-) (string, error) {
-	var resolvedCommit string
-
-	retryErr := retry.Do(env, retryCfg, func() error {
-		var resolveErr error
-
-		resolvedCommit, resolveErr = resolver.ResolveCommit(
-			env,
-			componentName,
-			config.Spec,
-			resolveUpstreamDistro(config.Spec, env.Config(), distroDef),
-			resolveUpstreamDistroVersion(config.Spec, env.Config(), distroVersionDef),
-		)
-		if resolveErr != nil {
-			return fmt.Errorf("resolving commit:\n%w", resolveErr)
-		}
-
-		return nil
-	})
-	if retryErr != nil {
-		slog.Warn("Could not resolve upstream commit; fingerprint may be incomplete",
-			"component", componentName, "error", retryErr)
-
-		return "", fmt.Errorf("resolving upstream commit for %#q:\n%w", componentName, retryErr)
-	}
-
-	return resolvedCommit, nil
-}
-
-// resolveDistroForIdentity resolves the default distro reference for upstream commit resolution.
-// Returns the distro ref with version populated if it was initially empty.
+// resolveDistroForIdentity resolves the default distro reference and returns a
+// [sourceproviders.ResolvedDistro] for constructing a source manager.
 func resolveDistroForIdentity(
 	env *azldev.Env, distroRef projectconfig.DistroReference,
-) (projectconfig.DistroReference, projectconfig.DistroDefinition, projectconfig.DistroVersionDefinition, error) {
+) (projectconfig.DistroReference, sourceproviders.ResolvedDistro, error) {
 	distroDef, distroVersionDef, err := env.ResolveDistroRef(distroRef)
 	if err != nil {
-		return distroRef, distroDef, distroVersionDef,
+		return distroRef, sourceproviders.ResolvedDistro{},
 			fmt.Errorf("resolving distro %#q:\n%w", distroRef.Name, err)
 	}
 
@@ -297,53 +237,11 @@ func resolveDistroForIdentity(
 		distroRef.Version = distroDef.DefaultVersion
 	}
 
-	return distroRef, distroDef, distroVersionDef, nil
-}
-
-// resolveUpstreamDistro returns the distro definition for the component's upstream distro,
-// falling back to the default project distro if the component doesn't specify one.
-func resolveUpstreamDistro(
-	spec projectconfig.SpecSource,
-	config *projectconfig.ProjectConfig,
-	defaultDef projectconfig.DistroDefinition,
-) projectconfig.DistroDefinition {
-	if spec.UpstreamDistro.Name == "" {
-		return defaultDef
-	}
-
-	if upstreamDef, found := config.Distros[spec.UpstreamDistro.Name]; found {
-		return upstreamDef
-	}
-
-	return defaultDef
-}
-
-// resolveUpstreamDistroVersion returns the distro version definition for the upstream distro,
-// falling back to the default if not found.
-func resolveUpstreamDistroVersion(
-	spec projectconfig.SpecSource,
-	config *projectconfig.ProjectConfig,
-	defaultVersionDef projectconfig.DistroVersionDefinition,
-) projectconfig.DistroVersionDefinition {
-	if spec.UpstreamDistro.Name == "" {
-		return defaultVersionDef
-	}
-
-	upstreamDef, found := config.Distros[spec.UpstreamDistro.Name]
-	if !found {
-		return defaultVersionDef
-	}
-
-	version := spec.UpstreamDistro.Version
-	if version == "" {
-		version = upstreamDef.DefaultVersion
-	}
-
-	if versionDef, vFound := upstreamDef.Versions[version]; vFound {
-		return versionDef
-	}
-
-	return defaultVersionDef
+	return distroRef, sourceproviders.ResolvedDistro{
+		Ref:        distroRef,
+		Definition: distroDef,
+		Version:    distroVersionDef,
+	}, nil
 }
 
 // countAffectsCommits counts the number of "Affects: <componentName>" commits in the

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

@@ -35,13 +35,11 @@ type ComponentIdentity struct {
 type ComponentInputs struct {
 	// ConfigHash is the hash of the resolved component config fields (uint64 from hashstructure).
 	ConfigHash uint64 `json:"configHash"`
-	// SpecContentHash is the SHA256 of the spec file content (local specs only).
-	SpecContentHash string `json:"specContentHash,omitempty"`
+	// SourceIdentity is the opaque identity string for the component's source.
+	// For local specs this is a content hash; for upstream specs this is a commit hash.
+	SourceIdentity string `json:"sourceIdentity,omitempty"`
 	// OverlayFileHashes maps overlay source file paths to their SHA256 hashes.
 	OverlayFileHashes map[string]string `json:"overlayFileHashes,omitempty"`
-	// ResolvedUpstreamCommit is the concrete upstream commit hash for upstream specs.
-	// For pinned specs this is the pinned value; for floating specs it is resolved at runtime.
-	ResolvedUpstreamCommit string `json:"resolvedUpstreamCommit,omitempty"`
 	// AffectsCommitCount is the number of "Affects: <component>" commits in the project repo.
 	AffectsCommitCount int `json:"affectsCommitCount"`
 	// Distro is the effective distro name.
@@ -55,9 +53,8 @@ type ComponentInputs struct {
 type IdentityOptions struct {
 	// AffectsCommitCount is the number of "Affects: <component>" commits.
 	AffectsCommitCount int
-	// ResolvedUpstreamCommit is the concrete upstream commit hash for upstream specs.
-	// Leave empty for local specs.
-	ResolvedUpstreamCommit string
+	// SourceIdentity is the opaque identity string from a [sourceproviders.SourceIdentityProvider].
+	SourceIdentity string
 }
 
 // ComputeIdentity computes the fingerprint for a component from its resolved config
@@ -70,10 +67,10 @@ func ComputeIdentity(
 	opts IdentityOptions,
 ) (*ComponentIdentity, error) {
 	inputs := ComponentInputs{
-		AffectsCommitCount:     opts.AffectsCommitCount,
-		ResolvedUpstreamCommit: opts.ResolvedUpstreamCommit,
-		Distro:                 distroRef.Name,
-		DistroVersion:          distroRef.Version,
+		AffectsCommitCount: opts.AffectsCommitCount,
+		SourceIdentity:     opts.SourceIdentity,
+		Distro:             distroRef.Name,
+		DistroVersion:      distroRef.Version,
 	}
 
 	// 1. Hash the resolved config struct (excluding fingerprint:"-" fields).
@@ -86,20 +83,7 @@ func ComputeIdentity(
 
 	inputs.ConfigHash = configHash
 
-	// 2. Hash spec file content for local specs.
-	if component.Spec.SourceType == projectconfig.SpecSourceTypeLocal ||
-		component.Spec.SourceType == projectconfig.SpecSourceTypeUnspecified {
-		if component.Spec.Path != "" {
-			specHash, fileErr := fileutils.ComputeFileHash(fs, fileutils.HashTypeSHA256, component.Spec.Path)
-			if fileErr != nil {
-				return nil, fmt.Errorf("hashing spec file %#q:\n%w", component.Spec.Path, fileErr)
-			}
-
-			inputs.SpecContentHash = specHash
-		}
-	}
-
-	// 3. Hash overlay source file contents.
+	// 2. Hash overlay source file contents.
 	overlayHashes, err := hashOverlayFiles(fs, component.Overlays)
 	if err != nil {
 		return nil, fmt.Errorf("hashing overlay files:\n%w", err)
@@ -145,8 +129,7 @@ func combineInputs(inputs ComponentInputs) string {
 
 	// Write each input in a fixed order with field labels for domain separation.
 	writeField(hasher, "config_hash", strconv.FormatUint(inputs.ConfigHash, 10))
-	writeField(hasher, "spec_content_hash", inputs.SpecContentHash)
-	writeField(hasher, "resolved_upstream_commit", inputs.ResolvedUpstreamCommit)
+	writeField(hasher, "source_identity", inputs.SourceIdentity)
 	writeField(hasher, "affects_commit_count", strconv.Itoa(inputs.AffectsCommitCount))
 	writeField(hasher, "distro", inputs.Distro)
 	writeField(hasher, "distro_version", inputs.DistroVersion)