feat(component): place built RPMs/SRPMs into structured output dirs and validate channel names (#68)

Routes component build outputs into dedicated subdirectories under the project output dir, mirroring how a real publish pipeline organises packages.

Author: liunan-ms

docs/user/how-to/build-component.md

@@ -15,7 +15,14 @@ Build a component by name:
 azldev comp build -p <component-name>
 ```
 
-Built RPMs appear in the project's output directory (configured by `output-dir` in [project config](../reference/config/project.md)).
+Built packages are placed in structured subdirectories under the project's output directory
+(configured by `output-dir` in [project config](../reference/config/project.md)):
+
+| Directory | Contents |
+|-----------|----------|
+| `out/srpms/` | Source RPMs (SRPMs) |
+| `out/rpms/` | Binary RPMs with no channel configured, or channel `none` |
+| `out/rpms/<channel>/` | Binary RPMs assigned to a named publish channel |
 
 ## Common Options
 

docs/user/reference/cli/azldev_component_build.md

@@ -44,7 +44,7 @@ type ComponentBuildOptions struct {
 // RPMResult encapsulates a single binary RPM produced by a component build,
 // together with the resolved publish channel for that package.
 type RPMResult struct {
-	// Path is the absolute path to the RPM file.
+	// Path is the absolute path to the RPM file in the build output directory.
 	Path string `json:"path" table:"Path"`
 
 	// PackageName is the binary package name extracted from the RPM header tag (e.g., "libcurl-devel").
@@ -90,8 +90,16 @@ func NewBuildCmd() *cobra.Command {
 		Long: `Build RPM packages for one or more components using mock.
 
 This command fetches upstream sources (applying any configured overlays),
-creates an SRPM, and invokes mock to produce binary RPMs. Built packages
-are placed in the project's output directory.
+creates an SRPM, and invokes mock to produce binary RPMs. Build outputs
+are placed in structured subdirectories under the project output directory:
+
+  out/srpms/           - source RPMs (SRPMs)
+  out/rpms/            - binary RPMs with no channel configured (or channel="none")
+  out/rpms/<channel>/  - binary RPMs moved to their configured publish channel subdirectory
+
+The publish channel for each package is resolved from the project's package
+configuration (package groups and per-component overrides). See 'azldev package'
+for details.
 
 Use --local-repo-with-publish to build a chain of dependent components:
 each component's RPMs are published to a local repository that subsequent
@@ -281,10 +289,27 @@ func buildComponentUsingBuilder(
 	// Compose the path to the output dir.
 	outputDir := env.OutputDir()
 
-	// Make sure we have a final output dir.
+	// All binary RPMs land in out/rpms/ so they are kept separate from SRPMs
+	// and other build artifacts in out/.
+	rpmsDir := filepath.Join(outputDir, "rpms")
+
+	// SRPMs land in out/srpms/.
+	srpmsDir := filepath.Join(outputDir, "srpms")
+
+	// Make sure all output directories exist.
 	err = fileutils.MkdirAll(env.FS(), outputDir)
 	if err != nil {
-		return results, fmt.Errorf("failed to ensure dir %q exists: %w", outputDir, err)
+		return results, fmt.Errorf("failed to ensure dir %#q exists:\n%w", outputDir, err)
+	}
+
+	err = fileutils.MkdirAll(env.FS(), rpmsDir)
+	if err != nil {
+		return results, fmt.Errorf("failed to ensure dir %#q exists:\n%w", rpmsDir, err)
+	}
+
+	err = fileutils.MkdirAll(env.FS(), srpmsDir)
+	if err != nil {
+		return results, fmt.Errorf("failed to ensure dir %#q exists:\n%w", srpmsDir, err)
 	}
 
 	buildEvent := env.StartEvent("Building packages with mock", "component", component.GetName())
@@ -295,9 +320,9 @@ func buildComponentUsingBuilder(
 	// Build the SRPM.
 	//
 
-	outputSourcePackagePath, err := builder.BuildSourcePackage(env, component, localRepoPaths, outputDir)
+	outputSourcePackagePath, err := builder.BuildSourcePackage(env, component, localRepoPaths, srpmsDir)
 	if err != nil {
-		return results, fmt.Errorf("failed to build SRPM for %q:\n%w", component.GetName(), err)
+		return results, fmt.Errorf("failed to build SRPM for %#q:\n%w", component.GetName(), err)
 	}
 
 	// Start filling out results.
@@ -314,10 +339,10 @@ func buildComponentUsingBuilder(
 	//
 
 	results.RPMPaths, err = builder.BuildBinaryPackage(
-		env, component, outputSourcePackagePath, localRepoPaths, outputDir, noCheck,
+		env, component, outputSourcePackagePath, localRepoPaths, rpmsDir, noCheck,
 	)
 	if err != nil {
-		return results, fmt.Errorf("failed to build RPM for %q: %w", component.GetName(), err)
+		return results, fmt.Errorf("failed to build RPM for %#q:\n%w", component.GetName(), err)
 	}
 
 	// Enrich each RPM with its binary package name and resolved publish channel.
@@ -326,6 +351,17 @@ func buildComponentUsingBuilder(
 		return results, fmt.Errorf("failed to resolve publish channels for %#q:\n%w", component.GetName(), err)
 	}
 
+	// Move RPMs with a channel into out/rpms/<channel>/, leaving unconfigured ones in out/rpms/.
+	if err = PlaceRPMsByChannel(env, results.RPMs, rpmsDir); err != nil {
+		return results, fmt.Errorf("failed to place RPMs by channel for %#q:\n%w", component.GetName(), err)
+	}
+
+	// Sync RPMPaths to the final (possibly moved) locations.
+	results.RPMPaths = make([]string, len(results.RPMs))
+	for rpmIdx, rpm := range results.RPMs {
+		results.RPMPaths[rpmIdx] = rpm.Path
+	}
+
 	// Populate the parallel Channels slice for table display.
 	results.RPMChannels = make([]string, len(results.RPMs))
 	for rpmIdx, rpm := range results.RPMs {
@@ -343,6 +379,34 @@ func buildComponentUsingBuilder(
 	return results, nil
 }
 
+// PlaceRPMsByChannel moves each RPM with a configured channel from its initial location in
+// rpmsDir to a channel-specific subdirectory rpmsDir/<channel>/.
+// RPMs whose channel is empty or the reserved value "none" remain in rpmsDir.
+// [RPMResult.Path] is updated in-place to reflect the final location of each RPM.
+func PlaceRPMsByChannel(env *azldev.Env, rpmResults []RPMResult, rpmsDir string) error {
+	for rpmIdx, rpm := range rpmResults {
+		if rpm.Channel == "" || rpm.Channel == "none" {
+			continue
+		}
+
+		channelDir := filepath.Join(rpmsDir, rpm.Channel)
+
+		if err := fileutils.MkdirAll(env.FS(), channelDir); err != nil {
+			return fmt.Errorf("failed to create channel directory %#q:\n%w", channelDir, err)
+		}
+
+		destPath := filepath.Join(channelDir, filepath.Base(rpm.Path))
+
+		if err := env.FS().Rename(rpm.Path, destPath); err != nil {
+			return fmt.Errorf("failed to move package %#q to channel %#q:\n%w", rpm.PackageName, rpm.Channel, err)
+		}
+
+		rpmResults[rpmIdx].Path = destPath
+	}
+
+	return nil
+}
+
 // validateBuildOptions validates the build options before any work is done.
 func validateBuildOptions(env *azldev.Env, options *ComponentBuildOptions) error {
 	// Check for overlap between --local-repo and --local-repo-with-publish.

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

@@ -6,8 +6,13 @@ package component_test
 import (
 	"testing"
 
+	"github.com/microsoft/azure-linux-dev-tools/internal/app/azldev"
 	componentcmds "github.com/microsoft/azure-linux-dev-tools/internal/app/azldev/cmds/component"
+	"github.com/microsoft/azure-linux-dev-tools/internal/app/azldev/core/components"
 	"github.com/microsoft/azure-linux-dev-tools/internal/app/azldev/core/testutils"
+	"github.com/microsoft/azure-linux-dev-tools/internal/projectconfig"
+	"github.com/microsoft/azure-linux-dev-tools/internal/utils/fileperms"
+	"github.com/microsoft/azure-linux-dev-tools/internal/utils/fileutils"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
@@ -95,3 +100,213 @@ func TestValidateBuildOptions_NoOverlapWithDifferentPaths(t *testing.T) {
 	assert.Contains(t, err.Error(), "createrepo_c")
 	assert.NotContains(t, err.Error(), "appears in both")
 }
+
+func TestPlaceRPMsByChannel_EmptyChannelStaysInPlace(t *testing.T) {
+	t.Parallel()
+
+	testEnv := testutils.NewTestEnv(t)
+
+	const (
+		rpmsDir = "/output/rpms"
+		rpmPath = "/output/rpms/curl-8.0-1.rpm"
+	)
+
+	require.NoError(t, fileutils.WriteFile(testEnv.TestFS, rpmPath, []byte("rpm"), fileperms.PrivateFile))
+
+	rpmResults := []componentcmds.RPMResult{
+		{Path: rpmPath, PackageName: "curl", Channel: ""},
+	}
+
+	require.NoError(t, componentcmds.PlaceRPMsByChannel(testEnv.Env, rpmResults, rpmsDir))
+
+	// File stays at its original path; RPMResult.Path is unchanged.
+	assert.Equal(t, rpmPath, rpmResults[0].Path)
+	_, err := testEnv.TestFS.Stat(rpmPath)
+	assert.NoError(t, err, "original path should still exist")
+}
+
+func TestPlaceRPMsByChannel_NoneChannelStaysInPlace(t *testing.T) {
+	t.Parallel()
+
+	testEnv := testutils.NewTestEnv(t)
+
+	const (
+		rpmsDir = "/output/rpms"
+		rpmPath = "/output/rpms/debuginfo-8.0-1.rpm"
+	)
+
+	require.NoError(t, fileutils.WriteFile(testEnv.TestFS, rpmPath, []byte("rpm"), fileperms.PrivateFile))
+
+	rpmResults := []componentcmds.RPMResult{
+		{Path: rpmPath, PackageName: "debuginfo", Channel: "none"},
+	}
+
+	require.NoError(t, componentcmds.PlaceRPMsByChannel(testEnv.Env, rpmResults, rpmsDir))
+
+	assert.Equal(t, rpmPath, rpmResults[0].Path)
+	_, err := testEnv.TestFS.Stat(rpmPath)
+	assert.NoError(t, err, "original path should still exist")
+}
+
+func TestPlaceRPMsByChannel_NamedChannelMovesFile(t *testing.T) {
+	t.Parallel()
+
+	testEnv := testutils.NewTestEnv(t)
+
+	const (
+		rpmsDir      = "/output/rpms"
+		rpmPath      = "/output/rpms/curl-8.0-1.rpm"
+		expectedPath = "/output/rpms/base/curl-8.0-1.rpm"
+	)
+
+	require.NoError(t, fileutils.WriteFile(testEnv.TestFS, rpmPath, []byte("rpm"), fileperms.PrivateFile))
+
+	rpmResults := []componentcmds.RPMResult{
+		{Path: rpmPath, PackageName: "curl", Channel: "base"},
+	}
+
+	require.NoError(t, componentcmds.PlaceRPMsByChannel(testEnv.Env, rpmResults, rpmsDir))
+
+	// RPMResult.Path must be updated to the new location.
+	assert.Equal(t, expectedPath, rpmResults[0].Path)
+
+	// File must exist at the channel subdirectory.
+	_, err := testEnv.TestFS.Stat(expectedPath)
+	require.NoError(t, err, "file should exist at channel subdirectory")
+
+	// File must no longer exist at the original location.
+	_, err = testEnv.TestFS.Stat(rpmPath)
+	assert.Error(t, err, "file should have been moved away from the original path")
+}
+
+func TestPlaceRPMsByChannel_MultipleRPMsDifferentChannels(t *testing.T) {
+	t.Parallel()
+
+	testEnv := testutils.NewTestEnv(t)
+
+	const rpmsDir = "/output/rpms"
+
+	type rpmInput struct {
+		path    string
+		channel string
+	}
+
+	inputs := []rpmInput{
+		{"/output/rpms/curl-8.0-1.rpm", "base"},
+		{"/output/rpms/curl-devel-8.0-1.rpm", "devel"},
+		{"/output/rpms/curl-debuginfo-8.0-1.rpm", "none"},
+		{"/output/rpms/curl-static-8.0-1.rpm", ""},
+	}
+
+	rpmResults := make([]componentcmds.RPMResult, 0, len(inputs))
+
+	for _, in := range inputs {
+		require.NoError(t, fileutils.WriteFile(testEnv.TestFS, in.path, []byte("rpm"), fileperms.PrivateFile))
+
+		rpmResults = append(rpmResults, componentcmds.RPMResult{
+			Path: in.path, PackageName: "curl", Channel: in.channel,
+		})
+	}
+
+	require.NoError(t, componentcmds.PlaceRPMsByChannel(testEnv.Env, rpmResults, rpmsDir))
+
+	for _, result := range rpmResults {
+		switch result.Channel {
+		case "base":
+			assert.Equal(t, "/output/rpms/base/curl-8.0-1.rpm", result.Path)
+		case "devel":
+			assert.Equal(t, "/output/rpms/devel/curl-devel-8.0-1.rpm", result.Path)
+		case "none":
+			assert.Equal(t, "/output/rpms/curl-debuginfo-8.0-1.rpm", result.Path)
+		case "":
+			assert.Equal(t, "/output/rpms/curl-static-8.0-1.rpm", result.Path)
+		}
+
+		_, statErr := testEnv.TestFS.Stat(result.Path)
+		assert.NoError(t, statErr, "RPM should exist at its final resolved path")
+	}
+}
+
+func TestPlaceRPMsByChannel_MultipleRPMsSameChannel(t *testing.T) {
+	t.Parallel()
+
+	testEnv := testutils.NewTestEnv(t)
+
+	const rpmsDir = "/output/rpms"
+
+	paths := []string{
+		"/output/rpms/curl-8.0-1.rpm",
+		"/output/rpms/libcurl-8.0-1.rpm",
+	}
+
+	rpmResults := make([]componentcmds.RPMResult, 0, len(paths))
+
+	for _, path := range paths {
+		require.NoError(t, fileutils.WriteFile(testEnv.TestFS, path, []byte("rpm"), fileperms.PrivateFile))
+
+		rpmResults = append(rpmResults, componentcmds.RPMResult{
+			Path: path, PackageName: "curl", Channel: "base",
+		})
+	}
+
+	require.NoError(t, componentcmds.PlaceRPMsByChannel(testEnv.Env, rpmResults, rpmsDir))
+
+	assert.Equal(t, "/output/rpms/base/curl-8.0-1.rpm", rpmResults[0].Path)
+	assert.Equal(t, "/output/rpms/base/libcurl-8.0-1.rpm", rpmResults[1].Path)
+
+	for _, result := range rpmResults {
+		_, err := testEnv.TestFS.Stat(result.Path)
+		assert.NoError(t, err, "both RPMs should exist in the shared channel subdirectory")
+	}
+}
+
+func TestPlaceRPMsByChannel_EmptyInput(t *testing.T) {
+	t.Parallel()
+
+	testEnv := testutils.NewTestEnv(t)
+
+	err := componentcmds.PlaceRPMsByChannel(testEnv.Env, nil, "/output/rpms")
+	assert.NoError(t, err)
+}
+
+func makeEnvWithDirs(t *testing.T, workDir, outputDir string) *azldev.Env {
+	t.Helper()
+
+	base := testutils.NewTestEnv(t)
+
+	cfg := projectconfig.NewProjectConfig()
+	cfg.Project.WorkDir = workDir
+	cfg.Project.OutputDir = outputDir
+
+	options := azldev.NewEnvOptions()
+	options.DryRunnable = base.DryRunnable
+	options.EventListener = base.EventListener
+	options.Interfaces = base.TestInterfaces
+	options.Config = &cfg
+
+	return azldev.NewEnv(t.Context(), options)
+}
+
+func TestBuildComponents_NoWorkDir(t *testing.T) {
+	t.Parallel()
+
+	env := makeEnvWithDirs(t, "", "/output")
+	comps := components.NewComponentSet()
+
+	_, err := componentcmds.BuildComponents(env, comps, &componentcmds.ComponentBuildOptions{})
+
+	require.Error(t, err)
+	assert.Contains(t, err.Error(), "work dir")
+}
+
+func TestBuildComponents_NoOutputDir(t *testing.T) {
+	t.Parallel()
+
+	env := makeEnvWithDirs(t, "/work", "")
+	comps := components.NewComponentSet()
+
+	_, err := componentcmds.BuildComponents(env, comps, &componentcmds.ComponentBuildOptions{})
+
+	require.Error(t, err)
+	assert.Contains(t, err.Error(), "output dir")
+}