func()

in internal/agentdeployer/agent.go [236:322]
78 lines of code
15 McCabe index (conditional complexity)

func (d *DockerComposeAgentDeployer) installDockerCompose(ctx context.Context, agentInfo AgentInfo) (string, error) {
	customAgentDir, err := CreateDeployerDir(d.profile, fmt.Sprintf("docker-agent-%s-%s", d.agentName(), d.agentRunID))
	if err != nil {
		return "", fmt.Errorf("failed to create directory for custom agent files: %w", err)
	}

	hashDockerfile := []byte{}
	if agentInfo.Agent.ProvisioningScript.Contents != "" || agentInfo.Agent.PreStartScript.Contents != "" {
		err = d.installDockerfileResources(agentInfo.Agent.AgentSettings, customAgentDir)
		if err != nil {
			return "", fmt.Errorf("failed to create dockerfile resources: %w", err)
		}
		hashDockerfile, err = hashFile(filepath.Join(customAgentDir, dockerTestAgentDockerfile))
		if err != nil {
			return "", fmt.Errorf("failed to obtain has for Elastic Agent Dockerfile: %w", err)
		}
	}
	config, err := stack.LoadConfig(d.profile)
	if err != nil {
		return "", fmt.Errorf("failed to load config from profile: %w", err)
	}
	enrollmentToken := ""
	if config.ElasticsearchAPIKey != "" {
		// TODO: Review if this is the correct place to get the enrollment token.
		kibanaClient, err := stack.NewKibanaClientFromProfile(d.profile)
		if err != nil {
			return "", fmt.Errorf("failed to create kibana client: %w", err)
		}
		enrollmentToken, err = kibanaClient.GetEnrollmentTokenForPolicyID(ctx, agentInfo.Policy.ID)
		if err != nil {
			return "", fmt.Errorf("failed to get enrollment token for policy %q: %w", agentInfo.Policy.Name, err)
		}
	}

	// TODO: Include these settings more explicitly in `config`.
	fleetURL := "https://fleet-server:8220"
	kibanaHost := "https://kibana:5601"
	stackVersion := d.stackVersion
	if config.Provider != stack.ProviderCompose {
		kibanaHost = config.KibanaHost
	}
	if url, ok := config.Parameters[stack.ParamServerlessFleetURL]; ok {
		fleetURL = url
	}
	if version, ok := config.Parameters[stack.ParamServerlessLocalStackVersion]; ok {
		stackVersion = version
	}

	agentImage, err := selectElasticAgentImage(stackVersion, agentInfo.Agent.BaseImage)
	if err != nil {
		return "", nil
	}

	resourceManager := resource.NewManager()
	resourceManager.AddFacter(resource.StaticFacter{
		"agent_image":            agentImage,
		"user":                   agentInfo.Agent.User,
		"capabilities":           strings.Join(agentInfo.Agent.LinuxCapabilities, ","),
		"runtime":                agentInfo.Agent.Runtime,
		"pid_mode":               agentInfo.Agent.PidMode,
		"ports":                  strings.Join(agentInfo.Agent.Ports, ","),
		"dockerfile_hash":        hex.EncodeToString(hashDockerfile),
		"stack_version":          stackVersion,
		"fleet_url":              fleetURL,
		"kibana_host":            stack.DockerInternalHost(kibanaHost),
		"elasticsearch_username": config.ElasticsearchUsername,
		"elasticsearch_password": config.ElasticsearchPassword,
		"enrollment_token":       enrollmentToken,
	})

	resourceManager.RegisterProvider("file", &resource.FileProvider{
		Prefix: customAgentDir,
	})

	agentResources := []resource.Resource{
		&resource.File{
			Path:    dockerTestAgentDockerCompose,
			Content: staticSource.Template("_static/docker-agent-base.yml.tmpl"),
		},
	}
	results, err := resourceManager.Apply(agentResources)
	if err != nil {
		return "", fmt.Errorf("%w: %s", err, common.ProcessResourceApplyResults(results))
	}

	return customAgentDir, nil
}