chore: revert build task changes (#385)

Author: reubeno

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

@@ -4,7 +4,6 @@
 package component
 
 import (
-	"context"
 	"errors"
 	"fmt"
 
@@ -14,11 +13,9 @@ import (
 	"github.com/microsoft/azldev/internal/app/azldev/core/sources"
 	"github.com/microsoft/azldev/internal/app/azldev/core/workdir"
 	"github.com/microsoft/azldev/internal/buildenv"
-	"github.com/microsoft/azldev/internal/orchestration/artifacts"
-	"github.com/microsoft/azldev/internal/orchestration/orchestrator"
 	"github.com/microsoft/azldev/internal/providers/sourceproviders"
 	"github.com/microsoft/azldev/internal/utils/defers"
-	"github.com/samber/lo"
+	"github.com/microsoft/azldev/internal/utils/fileutils"
 	"github.com/spf13/cobra"
 )
 
@@ -81,6 +78,8 @@ func NewBuildCmd() *cobra.Command {
 
 func SelectAndBuildComponents(env *azldev.Env, options *ComponentBuildOptions,
 ) ([]ComponentBuildResults, error) {
+	var comps *components.ComponentSet
+
 	resolver := components.NewResolver(env)
 
 	comps, err := resolver.FindComponents(&options.ComponentFilter)
@@ -95,10 +94,10 @@ func SelectAndBuildComponents(env *azldev.Env, options *ComponentBuildOptions,
 		)
 	}
 
-	return buildComponents(env, comps, options)
+	return BuildComponents(env, comps, options)
 }
 
-func buildComponents(
+func BuildComponents(
 	env *azldev.Env, components *components.ComponentSet, options *ComponentBuildOptions,
 ) ([]ComponentBuildResults, error) {
 	if env.WorkDir() == "" {
@@ -114,18 +113,10 @@ func buildComponents(
 		return nil, fmt.Errorf("failed to create work dir factory:\n%w", err)
 	}
 
-	orchestrator, err := orchestrator.NewOrchestrator(env.FS(),
-		orchestrator.WithBuildDir(env.WorkDir()),
-		orchestrator.WithOutputDir(env.OutputDir()),
-	)
-	if err != nil {
-		return nil, fmt.Errorf("failed to create orchestrator:\n%w", err)
-	}
-
 	results := make([]ComponentBuildResults, 0, components.Len())
 
 	for _, component := range components.Components() {
-		componentResults, buildErr := BuildComponent(env, orchestrator, component, workDirFactory, options)
+		componentResults, buildErr := BuildComponent(env, component, workDirFactory, options)
 		if buildErr != nil {
 			buildErr = fmt.Errorf("failed to build %q:\n%w", component.GetName(), buildErr)
 		}
@@ -143,7 +134,6 @@ func buildComponents(
 
 func BuildComponent(
 	env *azldev.Env,
-	orchestrator *orchestrator.Orchestrator,
 	component components.Component,
 	workDirFactory *workdir.Factory,
 	options *ComponentBuildOptions,
@@ -179,119 +169,56 @@ func BuildComponent(
 
 	builder := componentbuilder.New(env, env.FS(), env, sourcePreparer, buildEnv, workDirFactory)
 
-	return buildComponentUsingBuilder(env, orchestrator, component, builder,
+	return buildComponentUsingBuilder(env, component, builder,
 		options.SourcePackageOnly, options.RunChecks,
 	)
 }
 
 func buildComponentUsingBuilder(
-	env *azldev.Env,
-	orchestrator *orchestrator.Orchestrator,
-	component components.Component,
-	builder *componentbuilder.Builder,
+	env *azldev.Env, component components.Component, builder *componentbuilder.Builder,
 	sourcePackageOnly, runChecks bool,
-) (ComponentBuildResults, error) {
-	buildEvent := env.StartEvent("Building packages with mock", "component", component.GetName())
-	defer buildEvent.End()
-
-	results := ComponentBuildResults{
-		ComponentName: component.GetName(),
-	}
-
-	srpmPath, err := buildSRPM(env.Context(), builder, component, orchestrator)
-	if err != nil {
-		return results, fmt.Errorf("failed to build SRPM for %q:\n%w", component.GetName(), err)
-	}
-
-	results.SRPMPaths = []string{srpmPath}
-
-	// Short circuit if we were asked only to build the SRPM.
-	if sourcePackageOnly {
-		return results, nil
-	}
-
-	rpmPaths, err := buildRPMs(env.Context(), builder, component, srpmPath, runChecks, orchestrator)
-	if err != nil {
-		return results, fmt.Errorf("failed to build RPMs for %q:\n%w", component.GetName(), err)
-	}
-
-	results.RPMPaths = rpmPaths
-
-	return results, nil
-}
-
-func buildRPMs(
-	ctx context.Context, builder componentbuilder.ComponentBuilder, component components.Component,
-	srpmPath string, runChecks bool, orchestrator *orchestrator.Orchestrator,
-) ([]string, error) {
-	// Issue #273: replace external task creation for each component with a single goal task
-	// and move creation of subtasks into the orchestrator and task factories.
-	binaryTaskBuilder, err := NewBinaryPackageTaskBuilder(builder, component, srpmPath, runChecks)
-	if err != nil {
-		return nil, fmt.Errorf("failed to create binary package task builder:\n%w", err)
-	}
-
-	err = orchestrator.AssignTaskServices(binaryTaskBuilder)
-	if err != nil {
-		return nil, fmt.Errorf("failed to assign task services for binary package task:\n%w", err)
-	}
+) (results ComponentBuildResults, err error) {
+	// Compose the path to the output dir.
+	outputDir := env.OutputDir()
 
-	binaryTask, err := binaryTaskBuilder.Build()
+	// Make sure we have a final output dir.
+	err = fileutils.MkdirAll(env.FS(), outputDir)
 	if err != nil {
-		return nil, fmt.Errorf("failed to build binary package task:\n%w", err)
+		return results, fmt.Errorf("failed to ensure dir %q exists: %w", outputDir, err)
 	}
 
-	rawBinaryArtifacts, err := orchestrator.RunTask(ctx, binaryTask)
-	if err != nil {
-		return nil, fmt.Errorf("failed to run binary package task:\n%w", err)
-	}
+	buildEvent := env.StartEvent("Building packages with mock", "component", component.GetName())
 
-	typedBinaryArtifacts, err := artifacts.Cast[*FileArtifact](rawBinaryArtifacts...)
-	if err != nil {
-		return nil, fmt.Errorf("failed to cast binary artifacts:\n%w", err)
-	}
+	defer buildEvent.End()
 
-	// Extract RPM paths from artifacts
-	return lo.Map(typedBinaryArtifacts, func(artifact *FileArtifact, _ int) string {
-		return artifact.Path
-	}), nil
-}
+	//
+	// Build the SRPM.
+	//
 
-func buildSRPM(
-	ctx context.Context, builder componentbuilder.ComponentBuilder, component components.Component,
-	orchestrator *orchestrator.Orchestrator,
-) (string, error) {
-	// Issue #273: replace external task creation for each component with a single goal task
-	// and move creation of subtasks into the orchestrator and task factories.
-	sourceTaskBuilder, err := NewSourcesTaskBuilder(builder, component)
-	if err != nil {
-		return "", fmt.Errorf("failed to create sources task builder:\n%w", err)
-	}
+	var outputSourcePackagePath string
 
-	err = orchestrator.AssignTaskServices(sourceTaskBuilder)
+	outputSourcePackagePath, err = builder.BuildSourcePackage(env, component, outputDir)
 	if err != nil {
-		return "", fmt.Errorf("failed to assign task services for sources task:\n%w", err)
+		return results, fmt.Errorf("failed to build SRPM for %q:\n%w", component.GetName(), err)
 	}
 
-	sourcesTask, err := sourceTaskBuilder.Build()
-	if err != nil {
-		return "", fmt.Errorf("failed to build sources task:\n%w", err)
-	}
+	// Start filling out results.
+	results.ComponentName = component.GetName()
+	results.SRPMPaths = []string{outputSourcePackagePath}
 
-	rawArtifacts, err := orchestrator.RunTask(ctx, sourcesTask)
-	if err != nil {
-		return "", fmt.Errorf("failed to run sources task:\n%w", err)
+	// Short circuit if we were asked only to build the SRPM.
+	if sourcePackageOnly {
+		return results, nil
 	}
 
-	if len(rawArtifacts) != 1 {
-		return "", fmt.Errorf("expected exactly one source package artifact for component %#q, got %d",
-			component.GetName(), len(rawArtifacts))
-	}
+	//
+	// Build the RPM.
+	//
 
-	typedArtifacts, err := artifacts.Cast[*FileArtifact](rawArtifacts...)
+	results.RPMPaths, err = builder.BuildBinaryPackage(env, component, outputSourcePackagePath, outputDir, runChecks)
 	if err != nil {
-		return "", fmt.Errorf("failed to cast artifact:\n%w", err)
+		return results, fmt.Errorf("failed to build RPM for %q: %w", component.GetName(), err)
 	}
 
-	return typedArtifacts[0].Path, nil
+	return results, nil
 }