feat: prepare for parallel-safe mock (#327)

* Add `GetInfo()` and `Destroy()` methods to `BuildEnv` interface.
* Revert generics usage in factory.go to mitigate type errors.
* Update `componentbuilder` to take in an already-constructed build environment.

Author: reubeno

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

@@ -9,12 +9,10 @@ import (
 	"fmt"
 
 	"github.com/microsoft/azldev/internal/app/azldev"
-	"github.com/microsoft/azldev/internal/app/azldev/core/buildenvfactory"
 	"github.com/microsoft/azldev/internal/app/azldev/core/componentbuilder"
 	"github.com/microsoft/azldev/internal/app/azldev/core/components"
 	"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/projectconfig"
@@ -91,35 +89,32 @@ func SelectAndBuildComponents(env *azldev.Env, options *ComponentBuildOptions,
 
 func buildComponents(
 	env *azldev.Env, components *components.ComponentSet, options *ComponentBuildOptions,
-) (results []ComponentBuildResults, err error) {
+) ([]ComponentBuildResults, error) {
 	if env.WorkDir() == "" {
-		return results, errors.New("can't build packages without valid work dir")
+		return nil, errors.New("can't build packages without valid work dir")
 	}
 
 	if env.OutputDir() == "" {
-		return results, errors.New("can't build packages without valid output dir")
+		return nil, errors.New("can't build packages without valid output dir")
 	}
 
 	workDirFactory, err := workdir.NewFactory(env.FS(), env.WorkDir(), env.ConstructionTime())
 	if err != nil {
-		return results, fmt.Errorf("failed to create work dir factory: %w", err)
-	}
-
-	buildEnvFactory, err := buildenvfactory.NewMockRootFactoryForEnv(env)
-	if err != nil {
-		return results, fmt.Errorf("failed to create mock root factory: %w", err)
+		return nil, fmt.Errorf("failed to create work dir factory: %w", err)
 	}
 
 	orchestrator, err := orchestrator.NewOrchestrator(env.FS(),
 		orchestrator.WithBuildDir(env.WorkDir()),
 		orchestrator.WithOutputDir(env.OutputDir()),
 	)
 	if err != nil {
-		return results, fmt.Errorf("failed to create orchestrator: %w", err)
+		return nil, fmt.Errorf("failed to create orchestrator: %w", err)
 	}
 
+	results := make([]ComponentBuildResults, 0, components.Len())
+
 	for _, component := range components.Components() {
-		componentResults, buildErr := BuildComponent(env, orchestrator, component, workDirFactory, buildEnvFactory, options)
+		componentResults, buildErr := BuildComponent(env, orchestrator, component, workDirFactory, options)
 		if buildErr != nil {
 			buildErr = fmt.Errorf("failed to build %q: %w", component.GetName(), buildErr)
 		}
@@ -140,7 +135,6 @@ func BuildComponent(
 	orchestrator *orchestrator.Orchestrator,
 	component components.Component,
 	workDirFactory *workdir.Factory,
-	buildEnvFactory *buildenv.MockRootFactory,
 	options *ComponentBuildOptions,
 ) (ComponentBuildResults, error) {
 	var (
@@ -157,8 +151,14 @@ func BuildComponent(
 		}
 	}
 
+	buildEnv, err := workdir.MkComponentBuildEnvironment(env, workDirFactory, component.GetConfig(), "build")
+	if err != nil {
+		return ComponentBuildResults{},
+			fmt.Errorf("failed to create build environment for component %q: %w", component.GetName(), err)
+	}
+
 	sourcePreparer := sources.NewPreparer(env, env, env.FS(), rpmContentsProvider)
-	builder := componentbuilder.New(env, env.FS(), env, sourcePreparer, buildEnvFactory, workDirFactory)
+	builder := componentbuilder.New(env, env.FS(), env, sourcePreparer, buildEnv, workDirFactory)
 
 	return buildComponentUsingBuilder(env, orchestrator, component, builder,
 		options.SourcePackageOnly, options.RunChecks,

internal/app/azldev/core/buildenvfactory/factory.go

@@ -12,11 +12,19 @@ import (
 	"github.com/microsoft/azldev/internal/projectconfig"
 )
 
+// NewFactoryForEnv creates a new factory that can produce a build environment of the given type.
+func NewFactoryForEnv(env *azldev.Env, buildEnvType buildenv.EnvType) (buildenv.Factory, error) {
+	switch buildEnvType {
+	case buildenv.EnvTypeMock:
+		return NewMockRootFactoryForEnv(env)
+	default:
+		return nil, fmt.Errorf("unknown build environment type '%s'", buildEnvType)
+	}
+}
+
 // NewRPMAwareFactoryForEnv creates a new RPM-aware factory that can produce build environments of
 // the given type.
-func NewRPMAwareFactoryForEnv(env *azldev.Env, buildEnvType buildenv.EnvType) (
-	factory buildenv.RPMAwareFactory, err error,
-) {
+func NewRPMAwareFactoryForEnv(env *azldev.Env, buildEnvType buildenv.EnvType) (buildenv.RPMAwareFactory, error) {
 	switch buildEnvType {
 	case buildenv.EnvTypeMock:
 		return NewMockRootFactoryForEnv(env)
@@ -26,11 +34,11 @@ func NewRPMAwareFactoryForEnv(env *azldev.Env, buildEnvType buildenv.EnvType) (
 }
 
 // NewMockRootFactory creates a new instance of [mockRootFactory] with the given environment.
-func NewMockRootFactoryForEnv(env *azldev.Env) (factory *buildenv.MockRootFactory, err error) {
+func NewMockRootFactoryForEnv(env *azldev.Env) (*buildenv.MockRootFactory, error) {
 	var distroVerDef projectconfig.DistroVersionDefinition
 
 	// Get the distro we're building for.
-	_, distroVerDef, err = env.Distro()
+	_, distroVerDef, err := env.Distro()
 	if err != nil {
 		return nil, fmt.Errorf("failed to resolve distro for build: %w", err)
 	}
@@ -52,7 +60,7 @@ func NewMockRootFactoryForEnv(env *azldev.Env) (factory *buildenv.MockRootFactor
 	}
 
 	// Get set up with mock.
-	factory, err = buildenv.NewMockRootFactory(env, mockConfigPath)
+	factory, err := buildenv.NewMockRootFactory(env, mockConfigPath)
 	if err != nil {
 		return nil, fmt.Errorf("failed to create mock root factory: %w", err)
 	}

internal/app/azldev/core/componentbuilder/componentbuilder.go

@@ -35,12 +35,12 @@ type ComponentBuilder interface {
 }
 
 type Builder struct {
-	dryRunnable     opctx.DryRunnable
-	fs              opctx.FS
-	eventListener   opctx.EventListener
-	sourcePreparer  sources.SourcePreparer
-	buildEnvFactory buildenv.RPMAwareFactory
-	workDirFactory  *workdir.Factory
+	dryRunnable    opctx.DryRunnable
+	fs             opctx.FS
+	eventListener  opctx.EventListener
+	sourcePreparer sources.SourcePreparer
+	buildEnv       buildenv.RPMAwareBuildEnv
+	workDirFactory *workdir.Factory
 }
 
 // Ensure that [Builder] implements the [ComponentBuilder] interface.
@@ -51,28 +51,23 @@ func New(
 	fs opctx.FS,
 	eventListener opctx.EventListener,
 	sourcePreparer sources.SourcePreparer,
-	buildEnvFactory buildenv.RPMAwareFactory,
+	buildEnv buildenv.RPMAwareBuildEnv,
 	workDirFactory *workdir.Factory,
 ) *Builder {
 	return &Builder{
-		dryRunnable:     dryRunnable,
-		fs:              fs,
-		eventListener:   eventListener,
-		sourcePreparer:  sourcePreparer,
-		buildEnvFactory: buildEnvFactory,
-		workDirFactory:  workDirFactory,
+		dryRunnable:    dryRunnable,
+		fs:             fs,
+		eventListener:  eventListener,
+		sourcePreparer: sourcePreparer,
+		buildEnv:       buildEnv,
+		workDirFactory: workDirFactory,
 	}
 }
 
 func (b *Builder) BuildSourcePackage(
 	ctx context.Context, component components.Component, outputDir string,
 ) (packagePath string, err error) { // NOTE: We intentionally name the returns for better self-documentation.
-	buildEnv, err := b.buildEnvFactory.CreateEnv(buildenv.CreateOptions{})
-	if err != nil {
-		return "", fmt.Errorf("failed to create build environment for component %q: %w", component.GetName(), err)
-	}
-
-	packagePath, err = b.buildSRPM(ctx, component, buildEnv, outputDir)
+	packagePath, err = b.buildSRPM(ctx, component, b.buildEnv, outputDir)
 	if err != nil {
 		return packagePath, fmt.Errorf("failed to build source package for component %#q: %w", component.GetName(), err)
 	}
@@ -84,12 +79,7 @@ func (b *Builder) BuildBinaryPackage(
 	ctx context.Context,
 	component components.Component, sourcePackagePath, outputDir string, runChecks bool,
 ) (packagePaths []string, err error) { // NOTE: We intentionally name the returns for better self-documentation.
-	buildEnv, err := b.buildEnvFactory.CreateEnv(buildenv.CreateOptions{})
-	if err != nil {
-		return nil, fmt.Errorf("failed to create build environment for component %q: %w", component.GetName(), err)
-	}
-
-	packagePaths, err = b.buildRPM(ctx, component, sourcePackagePath, buildEnv, outputDir, runChecks)
+	packagePaths, err = b.buildRPM(ctx, component, sourcePackagePath, b.buildEnv, outputDir, runChecks)
 	if err != nil {
 		return packagePaths, fmt.Errorf("failed to build binary package for component %#q: %w", component.GetName(), err)
 	}

internal/app/azldev/core/componentbuilder/componentbuilder_test.go

@@ -32,11 +32,10 @@ type componentBuilderTestParams struct {
 	ctrl    *gomock.Controller
 	testEnv *testutils.TestEnv
 
-	sourcePreparer  sources.SourcePreparer
-	buildEnvFactory *buildenv_testutils.MockRPMAwareFactory
-	buildEnv        *buildenv_testutils.MockRPMAwareBuildEnv
-	workDirFactory  *workdir.Factory
-	builder         *componentbuilder.Builder
+	sourcePreparer sources.SourcePreparer
+	buildEnv       *buildenv_testutils.MockRPMAwareBuildEnv
+	workDirFactory *workdir.Factory
+	builder        *componentbuilder.Builder
 }
 
 func setupBuilder(t *testing.T) *componentBuilderTestParams {
@@ -56,22 +55,20 @@ func setupBuilder(t *testing.T) *componentBuilderTestParams {
 		sourcePreparer: sources.NewPreparer(
 			testEnv.DryRunnable, testEnv.Env, testEnv.Env.FS(), rpmContentsProvider,
 		),
-		buildEnvFactory: buildenv_testutils.NewMockRPMAwareFactory(ctrl),
-		workDirFactory:  workDirFactory,
+		workDirFactory: workDirFactory,
 	}
 
 	// Create a mocked-up RPM-aware build environment. Other method can be used to configure
 	// it to simulate build behavior.
 	params.buildEnv = buildenv_testutils.NewMockRPMAwareBuildEnv(ctrl)
-	params.buildEnvFactory.EXPECT().CreateEnv(gomock.Any()).AnyTimes().Return(params.buildEnv, nil)
 
 	// Create a builder that we'll test.
 	params.builder = componentbuilder.New(
 		testEnv.Env,
 		testEnv.Env.FS(),
 		testEnv.Env,
 		params.sourcePreparer,
-		params.buildEnvFactory,
+		params.buildEnv,
 		params.workDirFactory,
 	)
 

internal/app/azldev/core/specs/spec.go

@@ -13,6 +13,7 @@ import (
 	"github.com/microsoft/azldev/internal/app/azldev/core/workdir"
 	"github.com/microsoft/azldev/internal/projectconfig"
 	"github.com/microsoft/azldev/internal/rpm"
+	"github.com/microsoft/azldev/internal/utils/defers"
 )
 
 // ComponentSpec provides abstract access to the build specification of a software component.
@@ -87,6 +88,9 @@ func (s *componentSpec) Parse() (specInfo *ComponentSpecDetails, err error) {
 		return nil, fmt.Errorf("failed to create build environment for component %q: %w", s.componentConfig.Name, err)
 	}
 
+	// Clean up the build environment before we return.
+	defer defers.HandleDeferError(func() error { return buildEnv.Destroy(s.env) }, &err)
+
 	// Extract the build options from the component; we'll need to honor them even in rpmspec
 	// in order to get the correct spec information.
 	buildOptions := rpm.BuildOptions{

internal/app/azldev/core/workdir/workdir.go

@@ -10,6 +10,7 @@ import (
 	"strings"
 	"time"
 
+	"github.com/google/uuid"
 	"github.com/microsoft/azldev/internal/app/azldev"
 	"github.com/microsoft/azldev/internal/app/azldev/core/buildenvfactory"
 	"github.com/microsoft/azldev/internal/buildenv"
@@ -80,7 +81,7 @@ func MkComponentBuildEnvironment(
 	factory *Factory,
 	component *projectconfig.ComponentConfig,
 	label string,
-) (buildEnv buildenv.BuildEnv, err error) {
+) (buildEnv buildenv.RPMAwareBuildEnv, err error) {
 	// Create a work directory for us to place the environment under.
 	workDir, err := factory.Create(component, label)
 	if err != nil {
@@ -95,11 +96,13 @@ func MkComponentBuildEnvironment(
 		return nil, fmt.Errorf("failed to create mock root factory: %w", err)
 	}
 
-	// Create the build environment.
-	buildEnv, err = buildEnvFactory.CreateEnv(
+	// Create the build environment with an auto-generated name.
+	buildEnv, err = buildEnvFactory.CreateRPMAwareEnv(
 		buildenv.CreateOptions{
+			Name:        uuid.New().String(),
 			Dir:         buildEnvDir,
 			UserCreated: false,
+			Description: fmt.Sprintf("Build: %s (%s)", component.Name, label),
 		},
 	)
 	if err != nil {

internal/buildenv/buildenv.go

@@ -7,7 +7,9 @@ package buildenv
 
 import (
 	"context"
+	"encoding/json"
 	"fmt"
+	"time"
 
 	"github.com/microsoft/azldev/internal/global/opctx"
 	"github.com/microsoft/azldev/internal/rpm/mock"
@@ -17,8 +19,16 @@ import (
 // environment. A build environment is a self-contained, intentionally constructed  environment that
 // can be used to run build-related operations. A mock root instance is an example of a build environment.
 type BuildEnv interface {
+	// GetInfo returns a [BuildEnvInfo] structure that contains information about the build
+	// environment. This information can be used to identify the build environment and its properties.
+	GetInfo() BuildEnvInfo
+
 	// CreateCmd builds a new [exec.Cmd] for running the given command within the build environment.
 	CreateCmd(ctx context.Context, args []string, options RunOptions) (cmd opctx.Cmd, err error)
+
+	// Destroy permanently (and irreversibly) destroys the build environment, removing its files from
+	// the filesystem.
+	Destroy(ctx opctx.Ctx) error
 }
 
 // SRPMBuildOptions encapsulates options that may be specified when building a source RPM package
@@ -96,3 +106,36 @@ func (f *EnvType) Set(value string) error {
 func (f *EnvType) Type() string {
 	return "buildenv type"
 }
+
+// BuildEnvInfo is a simple data structure that contains information about a [BuildEnv].
+type BuildEnvInfo struct {
+	// Name is the human-readable name moniker for the build environment.
+	Name string `json:"Name"`
+
+	// UserCreated indicates whether the build environment was created on behalf of a direct user request.
+	// If this is false, the build environment was created automatically as part of a larger operation.
+	UserCreated bool `json:"UserCreated"`
+
+	// Type is the type of build environment. This is used to determine which technology can be used
+	// to interact with the build environment.
+	Type EnvType `json:"Type"`
+
+	// CreationTime is the time when the build environment was created. This can be useful for users to
+	// better understanding their environments.
+	CreationTime time.Time `json:"CreationTime"`
+
+	// Dir is the directory under which the build environment's files are stored.
+	Dir string `json:"Dir"`
+
+	// Description optionally provides a human-readable description of the environment's purpose.
+	Description string `json:"Description"`
+}
+
+func (i *BuildEnvInfo) Serialize() (data []byte, err error) {
+	data, err = json.MarshalIndent(i, "", "  ")
+	if err != nil {
+		return nil, fmt.Errorf("failed to serialize build environment info: %w", err)
+	}
+
+	return data, nil
+}