Add serverless provider

internal/kibana/client.go

@@ -52,11 +52,11 @@ func NewClient(opts ...ClientOption) (*Client, error) {
 	// Allow to initialize version from tests.
 	var zeroVersion VersionInfo
 	if c.semver == nil || c.versionInfo == zeroVersion {
-		v, err := c.requestVersion()
+		v, err := c.requestStatus()
 		if err != nil {
 			return nil, fmt.Errorf("failed to get Kibana version: %w", err)
 		}
-		c.versionInfo = v
+		c.versionInfo = v.Version
 
 		c.semver, err = semver.NewVersion(c.versionInfo.Number)
 		if err != nil {

internal/kibana/status.go

@@ -42,43 +42,32 @@ func (c *Client) Version() (VersionInfo, error) {
 	return c.versionInfo, nil
 }
 
-func (c *Client) requestVersion() (VersionInfo, error) {
-	var version VersionInfo
+func (c *Client) requestStatus() (statusType, error) {
+	var status statusType
 	statusCode, respBody, err := c.get(StatusAPI)
 	if err != nil {
-		return version, fmt.Errorf("could not reach status endpoint: %w", err)
+		return status, fmt.Errorf("could not reach status endpoint: %w", err)
 	}
 
 	if statusCode != http.StatusOK {
-		return version, fmt.Errorf("could not get status data; API status code = %d; response body = %s", statusCode, respBody)
+		return status, fmt.Errorf("could not get status data; API status code = %d; response body = %s", statusCode, respBody)
 	}
 
-	var status statusType
 	err = json.Unmarshal(respBody, &status)
 	if err != nil {
-		return version, fmt.Errorf("unmarshalling response failed (body: \n%s): %w", respBody, err)
+		return status, fmt.Errorf("unmarshalling response failed (body: \n%s): %w", respBody, err)
 	}
 
-	return status.Version, nil
+	return status, nil
 }
 
 // CheckHealth checks the Kibana health
 func (c *Client) CheckHealth() error {
-	statusCode, respBody, err := c.get(StatusAPI)
+	status, err := c.requestStatus()
 	if err != nil {
 		return fmt.Errorf("could not reach status endpoint: %w", err)
 	}
 
-	if statusCode != http.StatusOK {
-		return fmt.Errorf("could not get status data; API status code = %d; response body = %s", statusCode, respBody)
-	}
-
-	var status statusType
-	err = json.Unmarshal(respBody, &status)
-	if err != nil {
-		return fmt.Errorf("unmarshalling response failed (body: \n%s): %w", respBody, err)
-	}
-
 	if status.Status.Overall.Level != "available" {
 		return fmt.Errorf("kibana in unhealthy state: %s", status.Status.Overall.Level)
 	}

internal/profile/_static/config.yml.example

@@ -1,4 +1,8 @@
 # Directory containing GeoIP databases for stacks managed by elastic-agent.
 # stack.geoip_dir: "/path/to/geoip_dir/"
+# Serverless project type to be created
 # stack.serverless.type: observability
+# Region where the Serverless project is going to be created
 # stack.serverless.region: aws-us-east-1
+# Elastic cloud host URL
+# stack.elastic_cloud.host: https://cloud.elastic.co

internal/serverless/client.go

@@ -42,12 +42,10 @@ var (
 
 func NewClient(opts ...ClientOption) (*Client, error) {
 	hostEnvName := ServerlessHostvironmentVariable
-	host, ok := os.LookupEnv(hostEnvName)
-	if !ok {
-		host = defaultHostURL
-	}
+	host := os.Getenv(hostEnvName)
 	if host == "" {
-		return nil, fmt.Errorf("unable to obtain value from %s environment variable", hostEnvName)
+		logger.Debugf("Using default host URL: %s", defaultHostURL)
+		host = defaultHostURL
 	}
 	apiKeyEnvName := ServerlessApiKeyEnvironmentVariable
 	apiKey := os.Getenv(apiKeyEnvName)
@@ -292,7 +290,7 @@ func (c *Client) GetProject(projectType, projectID string) (*Project, error) {
 	}
 	statusCode, respBody, err := c.get(ctx, resourcePath)
 	if err != nil {
-		return nil, fmt.Errorf("error deleting project: %w", err)
+		return nil, fmt.Errorf("error getting project: %w", err)
 	}
 
 	if statusCode == http.StatusNotFound {

internal/stack/serverless.go

@@ -26,8 +26,9 @@ const (
 	paramServerlessProjectType = "serverless_project_type"
 	paramServerlessFleetURL    = "serverless_fleet_url"
 
-	configRegion      = "stack.serverless.region"
-	configProjectType = "stack.serverless.type"
+	configRegion          = "stack.serverless.region"
+	configProjectType     = "stack.serverless.type"
+	configElasticCloudURL = "stack.elastic_agent.host"
 
 	defaultRegion      = "aws-us-east-1"
 	defaultProjectType = "observability"
@@ -127,12 +128,12 @@ func (sp *serverlessProvider) deleteProject(project *serverless.Project, options
 func (sp *serverlessProvider) currentProject(config Config) (*serverless.Project, error) {
 	projectID, found := config.Parameters[paramServerlessProjectID]
 	if !found {
-		return nil, fmt.Errorf("mssing serverless project id")
+		return nil, serverless.ErrProjectNotExist
 	}
 
 	projectType, found := config.Parameters[paramServerlessProjectType]
 	if !found {
-		return nil, fmt.Errorf("missing serverless project type")
+		return nil, serverless.ErrProjectNotExist
 	}
 
 	project, err := sp.client.GetProject(projectType, projectID)
@@ -202,7 +203,12 @@ func createProjectName(options Options) string {
 }
 
 func newServerlessProvider(profile *profile.Profile) (*serverlessProvider, error) {
-	client, err := serverless.NewClient()
+	host := profile.Config(configElasticCloudURL, "")
+	options := []serverless.ClientOption{}
+	if host != "" {
+		options = append(options, serverless.WithAddress(host))
+	}
+	client, err := serverless.NewClient(options...)
 	if err != nil {
 		return nil, fmt.Errorf("can't create serverless provider: %w", err)
 	}
@@ -223,7 +229,7 @@ func (sp *serverlessProvider) BootUp(options Options) error {
 		return err
 	}
 
-	if common.StringSliceContains(allowedProjectTypes, settings.Type) {
+	if !common.StringSliceContains(allowedProjectTypes, settings.Type) {
 		return fmt.Errorf("serverless project type not supported: %s", settings.Type)
 	}
 
@@ -277,7 +283,7 @@ func (sp *serverlessProvider) composeProjectName() string {
 }
 
 func (sp *serverlessProvider) localAgentComposeProject() (*compose.Project, error) {
-	composeFile := sp.profile.Path(profileStackPath, ServerlessComposeFile)
+	composeFile := sp.profile.Path(profileStackPath, SnapshotFile)
 	return compose.NewProject(sp.composeProjectName(), composeFile)
 }
 
@@ -299,7 +305,17 @@ func (sp *serverlessProvider) startLocalAgent(options Options, config Config) er
 
 	err = project.Up(compose.CommandOptions{ExtraArgs: []string{"-d"}})
 	if err != nil {
-		return fmt.Errorf("failed to start local agent: %w", err)
+		// At least starting on 8.6.0, fleet-server may be reconfigured or
+		// restarted after being healthy. If elastic-agent tries to enroll at
+		// this moment, it fails inmediately, stopping and making `docker-compose up`
+		// to fail too.
+		// As a workaround, try to give another chance to docker-compose if only
+		// elastic-agent failed.
+		fmt.Println("Elastic Agent failed to start, trying again.")
+		err = project.Up(compose.CommandOptions{ExtraArgs: []string{"-d"}})
+		if err != nil {
+			return fmt.Errorf("failed to start local agent: %w", err)
+		}
 	}
 
 	return nil
@@ -375,11 +391,12 @@ func (sp *serverlessProvider) Status(options Options) ([]ServiceStatus, error) {
 		return nil, err
 	}
 
+	serverlessVersion := fmt.Sprintf("serverless (%s)", project.Type)
 	var serviceStatus []ServiceStatus
 	for service, status := range projectServiceStatus {
 		serviceStatus = append(serviceStatus, ServiceStatus{
 			Name:    service,
-			Version: "serverless",
+			Version: serverlessVersion,
 			Status:  status,
 		})
 	}

internal/stack/serverlessresources.go

@@ -16,15 +16,10 @@ import (
 	"github.com/elastic/elastic-package/internal/profile"
 )
 
-const (
-	// ServerlessComposeFile is the docker-compose snapshot.yml file name.
-	ServerlessComposeFile = "serverless-elastic-agent.yml"
-)
-
 var (
 	serverlessStackResources = []resource.Resource{
 		&resource.File{
-			Path:    ServerlessComposeFile,
+			Path:    SnapshotFile,
 			Content: staticSource.Template("_static/serverless-elastic-agent.yml.tmpl"),
 		},
 		&resource.File{