MacOS support

README.md

@@ -60,6 +60,9 @@ To get the list of available tasks
 
 Run any `-h` on any of the available tasks for more information
 
+## MacOS support
+
+The `aws.create-vm` task should allow you to spin up a MacOS instance using `-o macos` flag. Note that spinning such an instance is expensive because it requires a dedicated host. When you have one running please reuse it instead of creating new instances every time you need it. The cleaner will automatically get rid of the dedicated hosts.
 ## Troubleshooting
 
 ### Environment and configuration

components/datadog/agent/host.go

@@ -69,7 +69,7 @@ func NewHostAgent(e config.Env, host *remoteComp.Host, options ...agentparams.Op
 }
 
 func (h *HostAgent) installScriptInstallation(env config.Env, params *agentparams.Params, baseOpts ...pulumi.ResourceOption) (command.Command, error) {
-	installCmdStr, err := h.manager.getInstallCommand(params.Version, params.AdditionalInstallParameters)
+	installCmdStr, err := h.manager.getInstallCommand(params.Version, env.AgentAPIKey(), params.AdditionalInstallParameters)
 	if err != nil {
 		return nil, err
 	}
@@ -83,7 +83,7 @@ func (h *HostAgent) installScriptInstallation(env config.Env, params *agentparam
 	installCmd, err := h.Host.OS.Runner().Command(
 		h.namer.ResourceName("install-agent"),
 		&command.Args{
-			Create: pulumi.Sprintf(installCmdStr, env.AgentAPIKey()),
+			Create: installCmdStr,
 		}, baseOpts...)
 	if err != nil {
 		return nil, err

components/datadog/agent/host_linuxos.go

@@ -25,7 +25,7 @@ func (am *agentLinuxManager) directInstallCommand(_ config.Env, packagePath stri
 	return am.targetOS.PackageManager().Ensure("./"+packagePath, nil, "", os.AllowUnsignedPackages(true), os.WithPulumiResourceOptions(opts...))
 }
 
-func (am *agentLinuxManager) getInstallCommand(version agentparams.PackageVersion, _ []string) (string, error) {
+func (am *agentLinuxManager) getInstallCommand(version agentparams.PackageVersion, apiKey pulumi.StringInput, _ []string) (pulumi.StringOutput, error) {
 	var commandLine string
 	testEnvVars := []string{}
 
@@ -59,10 +59,11 @@ func (am *agentLinuxManager) getInstallCommand(version agentparams.PackageVersio
 
 	commandLine = strings.Join(testEnvVars, " ")
 
-	return fmt.Sprintf(
+	commandLine = fmt.Sprintf(
 		`for i in 1 2 3 4 5; do curl -fsSL https://s3.amazonaws.com/dd-agent/scripts/%v -o install-script.sh && break || sleep $((2**$i)); done &&  for i in 1 2 3; do DD_API_KEY=%%s %v DD_INSTALL_ONLY=true bash install-script.sh  && exit 0 || sleep $((2**$i)); done; exit 1`,
 		fmt.Sprintf("install_script_agent%s.sh", version.Major),
-		commandLine), nil
+		commandLine)
+	return pulumi.Sprintf(commandLine, apiKey), nil
 }
 
 func (am *agentLinuxManager) getAgentConfigFolder() string {

components/datadog/agent/host_macos.go

@@ -0,0 +1,78 @@
+package agent
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/DataDog/test-infra-definitions/common/config"
+	"github.com/DataDog/test-infra-definitions/components/command"
+	"github.com/DataDog/test-infra-definitions/components/datadog/agentparams"
+	remoteComp "github.com/DataDog/test-infra-definitions/components/remote"
+
+	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
+)
+
+type agentMacOSManager struct {
+	host *remoteComp.Host
+}
+
+func newMacOSManager(host *remoteComp.Host) agentOSManager {
+	return &agentMacOSManager{host: host}
+}
+
+// directInstallCommand expects a locally provided .dmg or .pkg uploaded to the host; it will install it with installer
+func (am *agentMacOSManager) directInstallCommand(env config.Env, packagePath string, _ agentparams.PackageVersion, additionalInstallParameters []string, opts ...pulumi.ResourceOption) (command.Command, error) {
+	// Unsupported for now.
+	return nil, fmt.Errorf("installing directly from a dmg without the install script requires way too many step that would imply duplicating the install script code in there")
+}
+
+// getInstallCommand downloads appropriate pkg and installs it
+func (am *agentMacOSManager) getInstallCommand(version agentparams.PackageVersion, apiKey pulumi.StringInput, _ []string) (pulumi.StringOutput, error) {
+	// For macOS, use the official install script which supports DD_API_KEY and version envs,
+	// mirroring Linux flow but using the macOS path. The script detects OS and uses pkg.
+	// If pipeline is specified, we cannot use public script; we assume local package will be provided in that case.
+
+	exports := []string{}
+	if version.Major != "" {
+		exports = append(exports, fmt.Sprintf("DD_AGENT_MAJOR_VERSION=%s", version.Major))
+	}
+	if version.Minor != "" {
+		exports = append(exports, fmt.Sprintf("DD_AGENT_MINOR_VERSION=%s", version.Minor))
+	}
+
+	if version.PipelineID != "" {
+		exports = append(exports, fmt.Sprintf("DD_REPO_URL=https://dd-agent-macostesting.s3.amazonaws.com/ci/datadog-agent/pipeline-%s-%s", version.PipelineID, am.host.OS.Descriptor().Architecture))
+	}
+
+	env := strings.Join(exports, " ")
+	// Retry curl few times
+	cmd := fmt.Sprintf(`for i in 1 2 3 4 5; do curl -fsSL https://install.datadoghq.com/scripts/install_mac_os.sh -o install-script.sh && break || sleep $((2**$i)); done && for i in 1 2 3; do DD_API_KEY=%%s %%s %[1]s DD_INSTALL_ONLY=true bash install-script.sh && exit 0 || sleep $((2**$i)); done; exit 1`, env)
+	// Only the systemdaemon install is supported on macOS, because single user requires to interact with the pop-up.
+	pulumiCmdStr := pulumi.Sprintf(cmd, apiKey, pulumi.Sprintf("DD_SYSTEMDAEMON_INSTALL=true DD_SYSTEMDAEMON_USER_GROUP=%s:staff", am.host.Username))
+	return pulumiCmdStr, nil
+}
+
+func (am *agentMacOSManager) getAgentConfigFolder() string {
+	// macOS Agent config default
+	return "/opt/datadog-agent/etc"
+}
+
+func (am *agentMacOSManager) restartAgentServices(transform command.Transformer, opts ...pulumi.ResourceOption) (command.Command, error) {
+	// On macOS, the launchd service is "com.datadoghq.agent"
+	cmdName := am.host.Name() + "-restart-agent"
+	var cmdArgs command.RunnerCommandArgs = &command.Args{
+		Sudo:   true,
+		Create: pulumi.String("launchctl kickstart -k system/com.datadoghq.agent"),
+	}
+	if transform != nil {
+		cmdName, cmdArgs = transform(cmdName, cmdArgs)
+	}
+	return am.host.OS.Runner().Command(cmdName, cmdArgs, opts...)
+}
+
+func (am *agentMacOSManager) ensureAgentUninstalled(version agentparams.PackageVersion, opts ...pulumi.ResourceOption) (command.Command, error) {
+	// No-op the install script should support installing again when the agent is already installed
+	return am.host.OS.Runner().Command("no-op-uninstall-agent", &command.Args{
+		Create: pulumi.String("true"),
+	}, opts...)
+}

components/datadog/agent/host_os.go

@@ -16,7 +16,7 @@ import (
 // internal interface to be able to provide the different OS-specific commands
 type agentOSManager interface {
 	directInstallCommand(env config.Env, packagePath string, version agentparams.PackageVersion, additionalInstallParameters []string, opts ...pulumi.ResourceOption) (command.Command, error)
-	getInstallCommand(version agentparams.PackageVersion, additionalInstallParameters []string) (string, error)
+	getInstallCommand(version agentparams.PackageVersion, apiKey pulumi.StringInput, additionalInstallParameters []string) (pulumi.StringOutput, error)
 	getAgentConfigFolder() string
 	restartAgentServices(transform command.Transformer, opts ...pulumi.ResourceOption) (command.Command, error)
 	ensureAgentUninstalled(version agentparams.PackageVersion, opts ...pulumi.ResourceOption) (command.Command, error)
@@ -28,7 +28,9 @@ func getOSManager(host *remoteComp.Host) agentOSManager {
 		return newLinuxManager(host)
 	case os.WindowsFamily:
 		return newWindowsManager(host)
-	case os.MacOSFamily, os.UnknownFamily:
+	case os.MacOSFamily:
+		return newMacOSManager(host)
+	case os.UnknownFamily:
 		fallthrough
 	default:
 		panic(fmt.Sprintf("unsupported OS: %v", host.OS.Descriptor().Family()))

components/datadog/agent/host_windowsos.go

@@ -45,10 +45,10 @@ $ErrorActionPreference = 'Stop';
 	return am.host.OS.Runner().Command("install-agent", &command.Args{Create: pulumi.Sprintf(cmd, env.AgentAPIKey())}, opts...)
 }
 
-func (am *agentWindowsManager) getInstallCommand(version agentparams.PackageVersion, additionalInstallParameters []string) (string, error) {
+func (am *agentWindowsManager) getInstallCommand(version agentparams.PackageVersion, apiKey pulumi.StringInput, additionalInstallParameters []string) (pulumi.StringOutput, error) {
 	url, err := getAgentURL(version)
 	if err != nil {
-		return "", err
+		return pulumi.Sprintf(""), err
 	}
 
 	cmd := ""
@@ -73,11 +73,11 @@ for ($i=0; $i -lt 3; $i++) {
 `, url, localFilename)
 	installPackageCommandStr, err := am.getInstallPackageCommand(localFilename, version, additionalInstallParameters)
 	if err != nil {
-		return "", err
+		return pulumi.Sprintf(""), err
 	}
 	cmd += installPackageCommandStr
 
-	return cmd, nil
+	return pulumi.Sprintf(cmd, apiKey), nil
 }
 
 func (am *agentWindowsManager) getInstallPackageCommand(filePath string, version agentparams.PackageVersion, additionalInstallParameters []string) (string, error) {

components/datadog/agent/package.go

@@ -44,8 +44,8 @@ func GetPackagePath(localPath string, flavor tifos.Flavor, agentFlavor string, a
 		wantedExt = ".deb"
 	case tifos.WindowsServer:
 		wantedExt = ".msi"
-	case tifos.MacosOS, tifos.Unknown:
-		fallthrough
+	case tifos.MacosOS:
+		wantedExt = ".dmg"
 	default:
 		return "", fmt.Errorf("unsupported flavor for local packages installation: %s", flavor)
 	}

components/os/const.go

@@ -15,9 +15,9 @@ const (
 func ArchitectureFromString(archStr string) Architecture {
 	archStr = strings.ToLower(archStr)
 	switch archStr {
-	case "x86_64", "amd64", "": // Default architecture is AMD64
+	case "x86_64", "amd64", "", "x86_64_mac": // Default architecture is AMD64
 		return AMD64Arch
-	case "arm64", "aarch64":
+	case "arm64", "aarch64", "arm64_mac":
 		return ARM64Arch
 	default:
 		panic(fmt.Sprintf("unknown architecture: %s", archStr))

components/os/macos_descriptors.go

@@ -3,5 +3,5 @@ package os
 // Implements commonly used descriptors for easier usage
 var (
 	MacOSDefault = MacOSSonoma
-	MacOSSonoma  = NewDescriptorWithArch(MacosOS, "sonoma", ARM64Arch)
+	MacOSSonoma  = NewDescriptor(MacosOS, "sonoma")
 )

components/os/macos_servicemanagers.go

@@ -21,7 +21,7 @@
 	cmdName := s.e.CommonNamer().ResourceName("running", serviceName)
 	var cmdArgs command.RunnerCommandArgs = &command.Args{
 		Sudo:   true,
-		Create: pulumi.String(fmt.Sprintf("launchctl stop %s && launchctl start %s", serviceName, serviceName)),
+		Create: pulumi.String(fmt.Sprintf("launchctl kickstart -k %s'", serviceName, serviceName)),
 	}
 
 	// If a transform is provided, use it to modify the command name and args

resources/aws/ec2/dedicated_host.go

@@ -0,0 +1,63 @@
+package ec2
+
+import (
+	"fmt"
+
+	"github.com/DataDog/test-infra-definitions/common/config"
+	"github.com/DataDog/test-infra-definitions/common/utils"
+	"github.com/DataDog/test-infra-definitions/resources/aws"
+
+	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/ec2"
+	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
+)
+
+type DedicatedHostArgs struct {
+	// Mandatory
+	InstanceType string // e.g., "mac1.metal", "mac2.metal"
+
+	// Optional
+	AvailabilityZone string // If not specified, will use first available zone
+	HostRecovery     string // "on" or "off", defaults to "off"
+	Tags             pulumi.StringMap
+}
+
+// NewDedicatedHost creates an EC2 Dedicated Host for Mac instances
+func NewDedicatedHost(e aws.Environment, name string, args DedicatedHostArgs, opts ...pulumi.ResourceOption) (*ec2.DedicatedHost, error) {
+	if args.InstanceType == "" {
+		return nil, fmt.Errorf("InstanceType is required for dedicated host")
+	}
+
+	// Default values
+	if args.HostRecovery == "" {
+		args.HostRecovery = "off"
+	}
+
+	var availabilityZone pulumi.StringInput
+	if args.AvailabilityZone == "" {
+		// Use the same AZ as the first subnet
+		availabilityZone = e.RandomSubnets().Index(pulumi.Int(0)).ApplyT(func(subnetId string) (string, error) {
+			// Get subnet info to determine AZ
+			subnet, err := ec2.LookupSubnet(e.Ctx(), &ec2.LookupSubnetArgs{
+				Id: &subnetId,
+			}, e.WithProvider(config.ProviderAWS))
+			if err != nil {
+				return "", err
+			}
+			return subnet.AvailabilityZone, nil
+		}).(pulumi.StringOutput)
+	} else {
+		availabilityZone = pulumi.String(args.AvailabilityZone)
+	}
+
+	dedicatedHostArgs := &ec2.DedicatedHostArgs{
+		InstanceType:     pulumi.String(args.InstanceType),
+		AvailabilityZone: availabilityZone,
+		HostRecovery:     pulumi.String(args.HostRecovery),
+	}
+
+	return ec2.NewDedicatedHost(e.Ctx(),
+		e.Namer.ResourceName(name),
+		dedicatedHostArgs,
+		utils.MergeOptions(opts, e.WithProviders(config.ProviderAWS), pulumi.RetainOnDelete(true))..., // Retain on delete because deleting a dedicated host is not possible unless it lived for at least 24 hours, the cleanup will be done by test-infra-cleaner
+	)
+}

resources/aws/ec2/vm.go

@@ -23,6 +23,7 @@
 	// Optional
 	UserData           string
 	HTTPTokensRequired bool
+	HostId             pulumi.StringInput // For dedicated host tenancy
 }
 
 func NewInstance(e aws.Environment, name string, args InstanceArgs, opts ...pulumi.ResourceOption) (*ec2.Instance, error) {
@@ -45,6 +46,7 @@
 			"Name": e.Namer.DisplayName(255, pulumi.String(name)),
 		},
 		InstanceInitiatedShutdownBehavior: pulumi.String(e.DefaultShutdownBehavior()),
+		HostId:                            args.HostId,
 	}
 
 	if args.HTTPTokensRequired {

resources/aws/environment.go

@@ -37,6 +37,7 @@ const (
 	DDInfraDefaultShutdownBehavior         = "aws/defaultShutdownBehavior"
 	DDInfraDefaultInternalRegistry         = "aws/defaultInternalRegistry"
 	DDInfraDefaultInternalDockerhubMirror  = "aws/defaultInternalDockerhubMirror"
+	DDInfraUseMacosCompatibleSubnets       = "aws/useMacosCompatibleSubnets"
 
 	// AWS ECS
 	DDInfraEcsExecKMSKeyID                  = "aws/ecs/execKMSKeyID"
@@ -222,7 +223,13 @@ func (e *Environment) DefaultVPCID() string {
 }
 
 func (e *Environment) DefaultSubnets() []string {
-	return e.GetStringListWithDefault(e.InfraConfig, DDInfraDefaultSubnetsParamName, e.envDefault.ddInfra.defaultSubnets)
+	defaultSubnets := []string{}
+	for _, subnet := range e.envDefault.ddInfra.defaultSubnets {
+		if !e.UseMacosCompatibleSubnets() || subnet.MacOSCompatible {
+			defaultSubnets = append(defaultSubnets, subnet.ID)
+		}
+	}
+	return defaultSubnets
 }
 
 func (e *Environment) DefaultFakeintakeECSArns() []string {
@@ -280,6 +287,10 @@ func (e *Environment) DefaultShutdownBehavior() string {
 	return e.GetStringWithDefault(e.InfraConfig, DDInfraDefaultShutdownBehavior, e.envDefault.ddInfra.defaultShutdownBehavior)
 }
 
+func (e *Environment) UseMacosCompatibleSubnets() bool {
+	return e.GetBoolWithDefault(e.InfraConfig, DDInfraUseMacosCompatibleSubnets, e.envDefault.ddInfra.useMacosCompatibleSubnets)
+}
+
 // ECS
 func (e *Environment) ECSExecKMSKeyID() string {
 	return e.GetStringWithDefault(e.InfraConfig, DDInfraEcsExecKMSKeyID, e.envDefault.ddInfra.ecs.execKMSKeyID)